def on_server_start_btn_pressed(self):
if not self.auto_status:
#pass controller object as tcp server receives commands to execute functions that will interact with
#the robot that are defined in the controller
self.ServerThread = TcpServer(self.c)
#connect signal (emit in this workthread) and slot (function add)
self.connect(self.ServerThread,
QtCore.SIGNAL("update_led_label(QString, QString)"),
self.update_led_indicator)
self.connect(
self.ServerThread,
QtCore.SIGNAL("update_ultrasonic_orientation_lcd(QString)"),
self.update_ultrasonic_orientation_lcd)
self.connect(
self.ServerThread,
QtCore.SIGNAL("update_wheel_orientation_lcd(QString)"),
self.update_wheel_orientation_lcd)
self.connect(self.ServerThread, QtCore.SIGNAL("started()"),
self.server_started)
self.connect(self.ServerThread, QtCore.SIGNAL("finished()"),
self.server_finished)
#start thread
self.ServerThread.start()
else:
QtGui.QMessageBox.information(
self, "Unauthorized!",
"Please terminate autonomous thread before turning on controller mode"
)
def __init__(self, storage, referential, marshaller, port):
TcpServer.__init__(self, port)
self.logger = logging.getLogger(__name__)
self.storage = storage
self.marshaller = marshaller
self.referential = referential
self.order_books = {}
self.initialize_order_books()
self.handle_callbacks = {
MessageTypes.Logon.value: self.handle_logon,
MessageTypes.CreateOrder.value: self.handle_create_order
}
def __init__(self, storage: AbstractStorage, client_authentication: bool,
marshaller: Serialization, port: int):
TcpServer.__init__(self, port)
self.storage = storage
self.client_authentication = client_authentication
self.marshaller = marshaller
self.order_books = {}
self.handle_callbacks = {
MessageTypes.Logon.value: self.handle_logon,
MessageTypes.CreateOrder.value: self.handle_create_order
}
logger.info(
f"Client authentication has been [{'enabled' if self.client_authentication else 'disabled'}]"
)
def test_srv(self, my_socket):
my_socket = my_socket.return_value
socket = mock.Mock()
host = '127.0.0.1'
srv = TcpServer(host=host, port=4444)
my_socket.accept.return_value = (socket, host)
socket.recv.return_value = "ABC123"
assert srv._running == False
srv.run()
socket.send.assert_called_once_with("ABC123")
socket.close.assert_called_once_with()
my_socket.close.assert_called_once_with()
assert srv._running == False
def main():
config = create_config()
config_ready.send(sender=config)
# start tcp server
try:
tcp_server = TcpServer(config.get('network', 'listen_host'),
config.getint('network', 'listen_port'))
except IOError as e:
logger.error("Could not start TCP server: \"{0}\"".format(str(e)))
sys.exit(1)
peer_manager.local_address = (tcp_server.ip, tcp_server.port)
tcp_server.start()
peer_manager.start()
chain_manager.start()
# handle termination signals
def signal_handler(signum=None, frame=None):
logger.info('Signal handler called with signal {0}'.format(signum))
peer_manager.stop()
chain_manager.stop()
tcp_server.stop()
for sig in [signal.SIGTERM, signal.SIGHUP, signal.SIGQUIT, signal.SIGINT]:
signal.signal(sig, signal_handler)
# connect peer
if config.get('network', 'remote_host'):
peer_manager.connect_peer(
config.get('network', 'remote_host'),
config.getint('network', 'remote_port'))
# loop
while not peer_manager.stopped():
time.sleep(0.1)
if len(peer_manager.get_connected_peer_addresses()) > 2:
chain_manager.bootstrap_blockchain()
logger.info('exiting')
peer_manager.join()
logger.debug('main thread finished')
def _createServices(self, eventloop):
"""Hardcoding a list of services - later we might add auto-detection of services present"""
Airconditioner(self, self.config, eventloop)
AutoShade(self, self.config, eventloop)
AutoLight(self, self.config, eventloop)
HiFi(self, self.config, eventloop)
IrTrans(self, self.config, eventloop)
Kodi(self, self.config, eventloop)
Paradox(self, self.config, eventloop)
Projector(self, self.config, eventloop)
Scene(self, self.config, eventloop)
Schedule(self, self.config, eventloop)
SleepSense(self, self.config, eventloop)
SunRiseSet(self, self.config, eventloop)
ZWaveMios(self, self.config, eventloop)
# let's make this last:
TcpServer(self, self.config, eventloop)
def __init__(self, marshaller, port):
TcpServer.__init__(self, port)
self.marshaller = marshaller
self.referential = None
self.initialize_referential()
def initMainWindow(self):
# create Device Data Widget
self.devDataWidget = None
self.devGraphicWidget = None
self.devProgramWidget = None
self.contentWidgetList = []
# real time object
self.rtc = QTimer()
self.rtc.timeout.connect(self.onRtcTimeout)
self.onRtcTimeout()
self.rtc.start(1000)
self.versionLabel.setText(self.getVersion())
self.modalTextLabel.setText("单控模式")
# create mysql database
self.dataBase = DataBase()
self.dataBase.getAllDevices(DevAttr.monitorSubDevDict,
DevAttr.devAttrList)
self.dataBase.databaseState.connect(self.onDatabaseState)
self.dataBaseThread = QThread()
self.dataBase.moveToThread(self.dataBaseThread)
self.getMonitorDevice.connect(self.dataBase.onCreateDevicesInfo)
self.savingParaSetting.connect(self.dataBase.onSavingParaSetting)
self.dataBaseThread.start()
# frame
self.contentFrameLayout = QHBoxLayout()
self.contentFrame.setLayout(self.contentFrameLayout)
# self.contentFrameLayout.setContentsMargins(0,0,0,0)
# graphic view
self.devGraphicWidget = DeviceGraphicWidget(
self.getAllDevice()) # new widget
self.devGraphicWidget.sendDataToTcp.connect(self.sendDataToTcp)
self.contentFrameLayout.addWidget(self.devGraphicWidget)
self.contentWidgetList.append(self.devGraphicWidget)
# program running..
self.devProgramWidget = DevProgramWidget()
self.contentFrameLayout.addWidget(self.devProgramWidget)
self.contentWidgetList.append(self.devProgramWidget)
self.devProgramWidget.sendDataToTcp.connect(self.sendDataToTcp)
self.devProgramWidget.analogCtrl.connect(self.analogCtrl)
self.showAllDeviceInWidget()
# create tcp server, main function...
self.tcpServer = TcpServer()
self.tcpServerThread = QThread()
self.tcpServer.moveToThread(self.tcpServerThread)
self.tcpServer.getAllSubDev.connect(self.onTcpServerGetAllSubDev)
self.tcpServer.updateDeviceState.connect(
self.devGraphicWidget.onUpdateDeviceState)
self.tcpServer.updateParaSetting.connect(self.onTcpServerUpdateSetting)
self.tcpServer.operationalCtrl.connect(self.onTcpServerOperationalCtrl)
self.tcpServer.devConnectingInfo.connect(
self.onTcpServerGetDevConnectingInfo)
self.tcpServer.speedSet.connect(self.onTcpServerSpeedSet)
self.sendDataToTcp.connect(self.tcpServer.onDataToSend)
self.tcpServerThread.start()
# plc Socket
self.plcSocket = PlcSocket()
self.plcSocketThread = QThread()
self.plcSocket.moveToThread(self.plcSocketThread)
self.plcSocketManagement.connect(self.plcSocket.onTcpSocketManagement)
self.plcSocketThread.started.connect(self.plcSocket.initTcpSocket)
self.plcSocketThread.start()
# analog detection
self.analogDetection = AnalogDetection()
self.analogDetectionThread = QThread()
self.analogDetection.moveToThread(self.analogDetectionThread)
self.analogDetectionThread.started.connect(self.analogDetection.init)
self.analogCtrl.connect(self.analogDetection.onAnalogCtrl)
self.analogDetection.GPIOState.connect(self.onPhysicalGPIOState)
if not Config.Debug:
self.analogDetection.ControlModeSwitch.connect(
self.onControlModeSwitch)
self.analogDetectionThread.start()
# push button signal and slots
self.dataShowingPushButton.clicked.connect(
self.onDataShowingPushButtonClicked)
self.graphicShowingPushButton.clicked.connect(
self.onGraphicShowingPushButtonClicked)
self.autoRunningPushButton.clicked.connect(self.changeToProgramMode)
self.organizedPlayPushButton.clicked.connect(
self.onOrganizedPlayPushButtonClicked)
self.systemManagementPushButton.clicked.connect(
self.onSystemManagementPushButtonClicked)
self.netFramePushButton.clicked.connect(
self.onNetFramePushButtonClicked)
class MainWindow(QFrame, ui_mainwindow.Ui_Form):
plcSocketManagement = pyqtSignal(int)
getMonitorDevice = pyqtSignal(str, list)
getPlaysInfo = pyqtSignal()
sendDataToTcp = pyqtSignal(str, int,
list) # name, id, messageTypeId, action, data
savingParaSetting = pyqtSignal(str, int, int, int)
analogCtrl = pyqtSignal(int, int)
# ControlModeSwitch = pyqtSignal(int)
# PhysicalGPIOState = pyqtSignal(int, int)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.setupUi(self)
self.initMainWindow()
def initMainWindow(self):
# create Device Data Widget
self.devDataWidget = None
self.devGraphicWidget = None
self.devProgramWidget = None
self.contentWidgetList = []
# real time object
self.rtc = QTimer()
self.rtc.timeout.connect(self.onRtcTimeout)
self.onRtcTimeout()
self.rtc.start(1000)
self.versionLabel.setText(self.getVersion())
self.modalTextLabel.setText("单控模式")
# create mysql database
self.dataBase = DataBase()
self.dataBase.getAllDevices(DevAttr.monitorSubDevDict,
DevAttr.devAttrList)
self.dataBase.databaseState.connect(self.onDatabaseState)
self.dataBaseThread = QThread()
self.dataBase.moveToThread(self.dataBaseThread)
self.getMonitorDevice.connect(self.dataBase.onCreateDevicesInfo)
self.savingParaSetting.connect(self.dataBase.onSavingParaSetting)
self.dataBaseThread.start()
# frame
self.contentFrameLayout = QHBoxLayout()
self.contentFrame.setLayout(self.contentFrameLayout)
# self.contentFrameLayout.setContentsMargins(0,0,0,0)
# graphic view
self.devGraphicWidget = DeviceGraphicWidget(
self.getAllDevice()) # new widget
self.devGraphicWidget.sendDataToTcp.connect(self.sendDataToTcp)
self.contentFrameLayout.addWidget(self.devGraphicWidget)
self.contentWidgetList.append(self.devGraphicWidget)
# program running..
self.devProgramWidget = DevProgramWidget()
self.contentFrameLayout.addWidget(self.devProgramWidget)
self.contentWidgetList.append(self.devProgramWidget)
self.devProgramWidget.sendDataToTcp.connect(self.sendDataToTcp)
self.devProgramWidget.analogCtrl.connect(self.analogCtrl)
self.showAllDeviceInWidget()
# create tcp server, main function...
self.tcpServer = TcpServer()
self.tcpServerThread = QThread()
self.tcpServer.moveToThread(self.tcpServerThread)
self.tcpServer.getAllSubDev.connect(self.onTcpServerGetAllSubDev)
self.tcpServer.updateDeviceState.connect(
self.devGraphicWidget.onUpdateDeviceState)
self.tcpServer.updateParaSetting.connect(self.onTcpServerUpdateSetting)
self.tcpServer.operationalCtrl.connect(self.onTcpServerOperationalCtrl)
self.tcpServer.devConnectingInfo.connect(
self.onTcpServerGetDevConnectingInfo)
self.tcpServer.speedSet.connect(self.onTcpServerSpeedSet)
self.sendDataToTcp.connect(self.tcpServer.onDataToSend)
self.tcpServerThread.start()
# plc Socket
self.plcSocket = PlcSocket()
self.plcSocketThread = QThread()
self.plcSocket.moveToThread(self.plcSocketThread)
self.plcSocketManagement.connect(self.plcSocket.onTcpSocketManagement)
self.plcSocketThread.started.connect(self.plcSocket.initTcpSocket)
self.plcSocketThread.start()
# analog detection
self.analogDetection = AnalogDetection()
self.analogDetectionThread = QThread()
self.analogDetection.moveToThread(self.analogDetectionThread)
self.analogDetectionThread.started.connect(self.analogDetection.init)
self.analogCtrl.connect(self.analogDetection.onAnalogCtrl)
self.analogDetection.GPIOState.connect(self.onPhysicalGPIOState)
if not Config.Debug:
self.analogDetection.ControlModeSwitch.connect(
self.onControlModeSwitch)
self.analogDetectionThread.start()
# push button signal and slots
self.dataShowingPushButton.clicked.connect(
self.onDataShowingPushButtonClicked)
self.graphicShowingPushButton.clicked.connect(
self.onGraphicShowingPushButtonClicked)
self.autoRunningPushButton.clicked.connect(self.changeToProgramMode)
self.organizedPlayPushButton.clicked.connect(
self.onOrganizedPlayPushButtonClicked)
self.systemManagementPushButton.clicked.connect(
self.onSystemManagementPushButtonClicked)
self.netFramePushButton.clicked.connect(
self.onNetFramePushButtonClicked)
def onRtcTimeout(self):
self.timeLabel.setText(
QDateTime.currentDateTime().toString("yyyy/MM/dd dddd hh:mm:ss"))
@pyqtSlot(str, list)
def onTcpServerGetAllSubDev(self, monitorName, subDev):
if DevAttr.monitorSubDevDict.get(monitorName) == subDev:
print("Got same monitor device!", monitorName)
return
if DevAttr.monitorSubDevDict.get(monitorName) is None:
DevAttr.monitorSubDevDict.setdefault(monitorName, subDev)
else:
DevAttr.monitorSubDevDict[monitorName] = subDev
self.getMonitorDevice.emit(monitorName, subDev)
print("some thing changed...", subDev)
DevAttr.devAttrList = self.createDevInfoDict() # 需要等待数据库创建完成以后再生成此变量
self.showAllDeviceInWidget()
def getAllDevice(self):
allDevice = []
for key in DevAttr.monitorSubDevDict.keys():
for dev in DevAttr.monitorSubDevDict[key]:
allDevice.append(dev[1])
return allDevice
def createDevInfoDict(self):
devInfo = []
for key in DevAttr.monitorSubDevDict.keys():
for dev in DevAttr.monitorSubDevDict[key]:
devInfo.append(DevAttr(dev[0], dev[1]))
return devInfo
def showAllDeviceInWidget(self):
if self.devDataWidget is not None:
self.contentWidgetList.remove(self.devDataWidget)
self.contentFrameLayout.removeWidget(self.devDataWidget)
self.devDataWidget.deleteLater()
self.devDataWidget = DevDataWidget(DevAttr.devAttrList) # new widget
self.devDataWidget.sendDataToTcp.connect(self.sendDataToTcp)
self.contentFrameLayout.addWidget(self.devDataWidget)
self.contentWidgetList.append(self.devDataWidget)
self.showWidgetInContentWidget(widget=self.devDataWidget)
def onDataShowingPushButtonClicked(self):
DevAttr.OperationMode = DevAttr.SingleModeD
if self.devDataWidget is not None:
self.showWidgetInContentWidget(widget=self.devDataWidget)
self.modalTextLabel.setText("单控模式")
def onGraphicShowingPushButtonClicked(self):
DevAttr.OperationMode = DevAttr.SingleModeG
self.showWidgetInContentWidget(widget=self.devGraphicWidget)
self.modalTextLabel.setText("单控模式")
def changeToProgramMode(self):
if Config.Debug:
DevAttr.OperationMode = DevAttr.ProgramMode
self.showWidgetInContentWidget(widget=self.devProgramWidget)
self.modalTextLabel.setText("程控模式")
@pyqtSlot(int)
def onControlModeSwitch(self, mode):
if mode == AnalogDetection.GPIO_PROGRAM:
self.dataShowingPushButton.setEnabled(False)
self.graphicShowingPushButton.setEnabled(False)
DevAttr.OperationMode = DevAttr.ProgramMode
self.showWidgetInContentWidget(widget=self.devProgramWidget)
self.modalTextLabel.setText("程控模式")
elif mode == AnalogDetection.GPIO_SINGLE:
self.dataShowingPushButton.setEnabled(True)
self.graphicShowingPushButton.setEnabled(True)
self.onDataShowingPushButtonClicked()
self.modalTextLabel.setText("单控模式")
else:
self.modalTextLabel.setText("维保模式")
def onOrganizedPlayPushButtonClicked(self):
try:
organizedPlay = OrganizedPlay()
organizedPlay.playsActive.connect(
self.devProgramWidget.onAutoRunning)
print("organizedPlay exit code:", organizedPlay.exec_())
except Exception as e:
print("create organized play error", str(e))
def showWidgetInContentWidget(self, index=0, widget=None):
for w in self.contentWidgetList:
w.hide()
if widget is None:
if len(self.contentWidgetList) != 0:
self.contentWidgetList[0].show()
else:
widget.show()
def onDatabaseState(self, s):
if s:
self.databaseLabel.setText("数据库忙")
else:
self.databaseLabel.setText("数据库闲")
def onSystemManagementPushButtonClicked(self):
login = AccountLogin()
if login.exec_():
try:
sysManagement = SystemManagement()
sysManagement.somthingChanged.connect(
self.onSysManagementSomthingChanged)
sysManagement.exec_()
except Exception as e:
print(str(e))
def onNetFramePushButtonClicked(self):
try:
deviceNetGraphic = DeviceNetGraphic(self.getAllDevice())
for dev in self.getAllDevice():
deviceNetGraphic.stateChanged(dev, False, True)
deviceNetGraphic.showFullScreen()
deviceNetGraphic.exec_()
except Exception as e:
print(str(e))
@pyqtSlot(str, str)
def onSysManagementSomthingChanged(self, name, value):
self.plcSocketManagement.emit(1)
@pyqtSlot(int, dict)
def onTcpServerUpdateSetting(self, sec, setting):
try:
id = setting["DevId"]
targetPos = setting["targetPos"]
UpLimited = setting["UpLimited"]
DownLimited = setting["DownLimited"]
for dev in DevAttr.devAttrList:
if dev.devId == id:
dev.targetPos = targetPos
dev.upLimitedPos = UpLimited
dev.downLimitedPos = DownLimited
if dev.targetPos > 100:
dev.setStateWord(DevAttr.SW_LowerLimit)
else:
dev.clearStateWord(DevAttr.SW_LowerLimit)
dev.valueChanged.emit(dev.devId, dev.devName)
self.savingParaSetting.emit(dev.devName, targetPos,
UpLimited, DownLimited)
except Exception as e:
print("On Tcp Server update Setting", str(e))
@pyqtSlot(int, dict)
def onTcpServerOperationalCtrl(self, sec, content):
DevAttr.singleCtrlOperation[sec] = content["State"]
@pyqtSlot(int, dict)
def onTcpServerSpeedSet(self, sec, content):
DevAttr.singleCtrlSpeed[sec] = content["Value"]
def getVersion(self):
return "Version {}.{}.{}".format(sys.version_info[0],
sys.version_info[1],
sys.version_info[2])
@pyqtSlot(dict)
def onTcpServerGetDevConnectingInfo(self, info):
devIsConnecting = False
if isinstance(info, dict):
for name, id in info.items():
if name is not None:
devIsConnecting = True
break
if devIsConnecting:
self.internetLabel.setText(self.tr("设备已连接"))
else:
self.internetLabel.setText(self.tr("无设备连接"))
def closeEvent(self, *args, **kwargs):
login = AccountLogin()
if login.exec_():
args[0].accept()
else:
args[0].ignore()
def onPhysicalGPIOState(self, gpio, state):
if state == AnalogDetection.KEY_DOWN:
focusWidget = QApplication.focusWidget()
if focusWidget is None: return
if gpio == AnalogDetection.GPIO_TURN_NEXT:
tabKey = QKeyEvent(QEvent.KeyPress, Qt.Key_Right,
Qt.NoModifier, "right")
QApplication.sendEvent(focusWidget, tabKey)
elif gpio == AnalogDetection.GPIO_TURN_PREV:
tabKey = QKeyEvent(QEvent.KeyPress, Qt.Key_Left, Qt.NoModifier,
"left")
QApplication.sendEvent(focusWidget, tabKey)
elif gpio == AnalogDetection.GPIO_RUN:
tabKey = QKeyEvent(QEvent.KeyPress, Qt.Key_F5, Qt.NoModifier,
"f5")
QApplication.sendEvent(focusWidget, tabKey)
elif gpio == AnalogDetection.GPIO_STOP:
tabKey = QKeyEvent(QEvent.KeyPress, Qt.Key_F6, Qt.NoModifier,
"f6")
QApplication.sendEvent(focusWidget, tabKey)
import re
from tcpserver import TcpServer
from boebot import BoeBot
import time, os
boebot = BoeBot()
tcp = TcpServer()
while True:
try:
command = tcp.command()
if len(command) > 0:
print('command', command)
# ------- to be designed by students ---------
if command == 'l':
boebot.rotateLeft()
elif command == 'r':
boebot.rotateRight()
elif command == 'f':
boebot.goForward()
elif command == 'b':
boebot.goBackward()
elif command == 's':
boebot.stop()
# --------------------------------------------
time.sleep(0.1)
except Exception as e:
print('main', e)
os._exit(1)
#线程函数
def keyBordInput(server):
while True:
msg = input('send to ' + str(server.remoteAdr) + ':')
if msg == 'quit' or server._closed:
break
try:
print("send...")
server.send(msg)
except RuntimeError as error:
print(error.with_traceback())
print("socket connection broken")
break
server.client.close()
return
'''
普通的服务器端程序
'''
if __name__ == "__main__":
server = TcpServer(6002)
server.bind()
server.listening()
#以函数的形式启动线程
ct = threading.Thread(target=keyBordInput, args=[server])
ct.start()
server.receive()
ct.join
server.close()
print('server is closed!')
try:
print("send...")
server.crytoSend(msg)
except RuntimeError as error:
print(error.with_traceback())
print("socket connection broken")
break
server.client.close()
return
'''
加密的服务器端程序
'''
if __name__ == "__main__":
server = TcpServer(6001)
server.bind()
server.listening()
#产生加密模块
cryto = CryptoModule()
publicKey = cryto.exportPublicKey()
server.client.send(publicKey[0:]) #发送公钥
receive = server.client.recv(2048)
aseKey = cryto.RsaDecryptCipher.decrypt(receive) #解密ASE私钥
# print('-------------AseKey------------')
# print(len(aseKey))
# print(aseKey.decode())
cryto.importAseKey(aseKey)
server.setCryto(cryto)
#以函数的形式启动线程
ct = threading.Thread(target=keyBordInput, args=[server])
class Main(QWidget, Ui_Form):
"""---------------CLASS CONSTRUCTOR---------------------"""
def __init__(self, parent=None):
QWidget.__init__(self, parent)
#method to setup the UI, defined in server_ui.py
self.setupUi(self)
#controller is instantiated here so it can be accessible
#for arduino thread, controler thread
#and tcpServer thread
self.c = Controller()
#start arduino thread
self.start_arduino_thread()
#auto thread status
self.auto_status = False
#server thread status
self.server_status = False
"""---------------INSTANCE METHODS---------------------"""
"""SLOT FUNCTIONS"""
#UPDATE UI LED INDICATOR
def update_led_indicator(self, led, text):
if led == "red":
self.red_label.setStyleSheet(text)
self.green_label.setStyleSheet("background-color: white")
self.blue_label.setStyleSheet("background-color: white")
elif led == "green":
self.red_label.setStyleSheet("background-color: white")
self.green_label.setStyleSheet(text)
self.blue_label.setStyleSheet("background-color: white")
elif led == "blue":
self.red_label.setStyleSheet("background-color: white")
self.green_label.setStyleSheet("background-color: white")
self.blue_label.setStyleSheet(text)
elif led == "off":
self.red_label.setStyleSheet(text)
self.green_label.setStyleSheet(text)
self.blue_label.setStyleSheet(text)
#UPDATE ULTRASONIC SENSOR LCD SCREEN
def update_ultrasonic_distance_lcd(self, text):
self.ultrasonic_distance_lcd.display(text)
#UPDATE ULTRASONIC ORIENTATION LCD SCREEN
def update_ultrasonic_orientation_lcd(self, text):
self.ultrasonic_orientation_lcd.display(text)
#UPDATE CAR ORIENTATION LCD SCREEN
def update_wheel_orientation_lcd(self, text):
self.wheel_orientation_lcd.display(text)
#SERVER STARTED NOTIFICATION AND UI UPDATE
def server_started(self):
self.controller_label.setStyleSheet("background-color: green")
QtGui.QMessageBox.information(self, "Started!",
"Server thread started")
self.server_status = True
#SERVER FINISHED NOTIFICATINO AND UI UPDATE
def server_finished(self):
self.controller_label.setStyleSheet("background-color: white")
QtGui.QMessageBox.information(self, "Finished!",
"Server thread finished")
self.server_status = False
#AUTONOMOUS MODE STARTED NOTIFICATION AND UI UPDATE
def auto_started(self):
self.auto_label.setStyleSheet("background-color: green")
QtGui.QMessageBox.information(self, "Started!",
"Autonomous mode thread started")
self.auto_status = True
#AUTONOMOUS MODE FINISHED NOTIFICATINO AND UI UPDATE
def auto_finished(self):
self.auto_label.setStyleSheet("background-color: white")
QtGui.QMessageBox.information(self, "Finished!",
"Autonomous mode thread finished")
self.auto_status = False
"""PyQt BUTTON LISTENERS MANAGING THREADS"""
#START TCP SERVER THREAD
@pyqtSignature("")
def on_server_start_btn_pressed(self):
if not self.auto_status:
#pass controller object as tcp server receives commands to execute functions that will interact with
#the robot that are defined in the controller
self.ServerThread = TcpServer(self.c)
#connect signal (emit in this workthread) and slot (function add)
self.connect(self.ServerThread,
QtCore.SIGNAL("update_led_label(QString, QString)"),
self.update_led_indicator)
self.connect(
self.ServerThread,
QtCore.SIGNAL("update_ultrasonic_orientation_lcd(QString)"),
self.update_ultrasonic_orientation_lcd)
self.connect(
self.ServerThread,
QtCore.SIGNAL("update_wheel_orientation_lcd(QString)"),
self.update_wheel_orientation_lcd)
self.connect(self.ServerThread, QtCore.SIGNAL("started()"),
self.server_started)
self.connect(self.ServerThread, QtCore.SIGNAL("finished()"),
self.server_finished)
#start thread
self.ServerThread.start()
else:
QtGui.QMessageBox.information(
self, "Unauthorized!",
"Please terminate autonomous thread before turning on controller mode"
)
#START AUTONOMOUS MODE
@pyqtSignature("")
def on_auto_on_btn_pressed(self):
if not self.server_status:
self.AutoThread = Auto_Thread(self.c)
self.connect(self.AutoThread, QtCore.SIGNAL("started()"),
self.auto_started)
self.connect(self.AutoThread, QtCore.SIGNAL("finished()"),
self.auto_finished)
#start thread
self.AutoThread.start()
else:
QtGui.QMessageBox.information(
self, "Unauthorized!",
"Please disconnect client before turning on autonomous mode")
#START AUTONOMOUS MODE
@pyqtSignature("")
def on_auto_off_btn_pressed(self):
self.AutoThread.finish_thread()
"""THREAD FUNCTIONS AUTOMATICALLY TRIGGERED"""
#START ARDUINO SENSING THREAD
def start_arduino_thread(self):
#pass the controllet object so it can upload the sensor data to the controller instance
#pass the Main object, inheriting from Ui_Form, to be able to upload sensor values in PyQt
#using a QThread that will be able to talk to this thread (main one)
#through signals and slots
self.ArduinoThread = Arduino_Thread(self.c)
#connect signal (emit in this workthread) and slot (function add)
self.connect(self.ArduinoThread,
QtCore.SIGNAL("update_led_label(QString, QString)"),
self.update_led_indicator)
self.connect(self.ArduinoThread,
QtCore.SIGNAL("update_ultrasonic_distance_lcd(QString)"),
self.update_ultrasonic_distance_lcd)
#start thread
self.ArduinoThread.start()