示例#1
0
    def setupSocketThread (self):
        self.socket = None
        
        if self.mock == True:
            QtCore.qDebug("MOCK MODE ON")
            self.socket = SocketMock()
        else:
          try:
              self.socket = serial.Serial(3,115200)
          except SerialException as e:
              QtCore.qDebug("Exception catched!")
              QtGui.QMessageBox.about(self, "Error", "Socket in use")

        self.thread = SerialCommunicationThread(self.socket)
        self.thread.start()
示例#2
0
class MainWindow(QtGui.QMainWindow):
    def __init__(self, mock = None):
        super(QtGui.QMainWindow, self).__init__()

        QtGui.QApplication.setStyle(QtGui.QStyleFactory.create("Plastique"));
        self.setWindowTitle("Mini Yatt")
        self.mock = mock

        self.mode = Mode.MANUAL_PLAYER_MODE

        self.currentCmd = 0 

        self.setupSocketThread()
        self.createCentralWidget()

        self.lineEdit.returnPressed.connect(self.sendData)
        self.connect(self.thread, QtCore.SIGNAL("newData"), self.readNewData)
				
        self.createShortcuts()
        self.createActions()
        self.createToolbar()
        self.createActionGroup()
        self.createMenus()
        
        self.readSettings()
        self.connect(self.scenarioComboBox, 
                      QtCore.SIGNAL("currentIndexChanged( const QString)"),                                                  self.selectScenario)

        for sequenceName in sorted(SequenceFactory().getAllSequenceNames()):
            print(sequenceName)
            self.scenarioComboBox.addItem(sequenceName)

    def subscribeForFilename(self):
        return "Log.miniyatt"

    def saveFile(self):
        filename = self.subscribeForFilename()
        file = QtCore.QFile(filename)
        if not file.open(QtCore.QFile.WriteOnly | QtCore.QFile.Text):
            QtGui.QMessageBox.warning(self, "Application",
                    "Cannot write file %s:\n%s." % (fileName, file.errorString()))
            return False

        outf = QtCore.QTextStream(file)
        outf << self.textEdit.toPlainText()
        file.close()
        return True

    def createToolbar(self):
        self.fileToolBar = self.addToolBar("ATCommands Toolbar")
        self.fileToolBar.addAction(self.addAct)

    def createCentralWidget(self):
        centralWidget = QWidget()
        self.setCentralWidget(centralWidget)

        self.lineEdit = QtGui.QLineEdit()
        self.textEdit = QtGui.QTextEdit()


        self.scenarioComboBox = QtGui.QComboBox(self)
        #                           currentIndexChanged = self.selectScenario )

        self.layout = QtGui.QVBoxLayout()
        self.layout.addWidget(self.lineEdit)
        self.layout.addWidget(self.textEdit)
        self.layout.addWidget(self.scenarioComboBox)
        centralWidget.setLayout(self.layout)

    def createAction(self, actionName, atCmd):
        newActionObject = QAction(actionName, self)
        newActionObject.setData(atCmd)
        return newActionObject

    def setupSocketThread (self):
        self.socket = None
        
        if self.mock == True:
            QtCore.qDebug("MOCK MODE ON")
            self.socket = SocketMock()
        else:
          try:
              self.socket = serial.Serial(3,115200)
          except SerialException as e:
              QtCore.qDebug("Exception catched!")
              QtGui.QMessageBox.about(self, "Error", "Socket in use")

        self.thread = SerialCommunicationThread(self.socket)
        self.thread.start()
            

    def createMenus(self):
        self.fileMenu = self.menuBar().addMenu("File")
        self.fileMenu.addAction(self.quitAct)
        self.fileMenu.addAction(self.saveAct)

        self.modeMenu = self.menuBar().addMenu("Mode")
        self.modeActionGroup = QActionGroup(self,triggered=self.modeActionTriggered)
        self.modeActionGroup.setExclusive(True)

        allModeList = []
        allModeList.append(["Manual Mode", False, Mode.MANUAL_MODE])
        allModeList.append(["Manual Player Mode",True,Mode.MANUAL_PLAYER_MODE])
        allModeList.append(["Pegasus Mode", False,Mode.PEGASUS_MODE])
        
        for modeData in allModeList:
            modeActionObject = QAction(modeData[0],self)
            modeActionObject.setCheckable(True)
            modeActionObject.setChecked(modeData[1])
            modeActionObject.setData(modeData[2])
            self.modeActionGroup.addAction(modeActionObject)
            self.modeMenu.addAction(modeActionObject)

    def createShortcuts(self):
        self.shortcut = QShortcut(QKeySequence("Ctrl+O"), self)
        self.shortcut.activated.connect(self.openFile)

        self.upArrow = QShortcut(QKeySequence("Up"), self)
        self.upArrow.activated.connect(self.previousCmd)

        self.downArrow = QShortcut(QKeySequence("Down"), self)
        self.downArrow.activated.connect(self.nextCmd)

    def previousCmd(self):
        QtCore.qDebug("Hello From Up")
        self.currentCmd -= 1

    def nextCmd(self):
        QtCore.qDebug("Hello From Down")
        self.currentCmd += 1
        
    def createActions(self):
        self.addAct = QAction(QIcon("addIcon16.png"), "Add", self, 
                                                triggered=self.addButton)

        #self.addButtonAct = QAction("Add Button",self,triggered=self.addButton)

        self.quitAct = QAction("Quit", self, shortcut=QKeySequence.Quit,
                                                 triggered=QtGui.qApp.quit)
        self.saveAct = QAction("Save", self, shortcut=QKeySequence.Save,
                                                 triggered=self.saveFile)

    def modeActionTriggered(self, action):
        QtCore.qDebug(str(action.data()))
        
        ###### PEGASUS MODE ########
        if action.data() == Mode.PEGASUS_MODE:
          QtCore.qDebug("PEGASUS MODE SELECTED - co powinienem dalej zrobic?")
  
          self.mode = Mode.PEGASUS_MODE

          #tutaj przyda sie jakis iterator
          currentSequence = self.scenarioComboBox.currentText()
          #self.commands = SequenceFactory().getNewSequence(currentSequence)
          self.commands = SequenceFactory().getNewSequence("cmu900")
          self.currentCmd = 0

          #TODO
          ### Wczytaj pierwsza sekwencje
          timeoutValue = self.commands[0].timeout
          self.response = deepcopy(self.commands[0].response)
          QtCore.qDebug("*****")
          QtCore.qDebug(repr(self.response))
          QtCore.qDebug("*****")
          
          
          self.sendDataMsg(self.commands[0].cmd)
          self.timer = Timer(timeoutValue, self.timeout)
          self.timer.start()
        

    def createActionGroup(self):
        self.actionGroup=QActionGroup(self,triggered=self.actionGroupTriggered)

        allActionsItemList = []
        allActionsItemList.append(["Bands?", "at^scfg=radio/band"])
        allActionsItemList.append(["at^moni", "at^moni"])
        allActionsItemList.append(["PIN","at+cpin=9999"])
        allActionsItemList.append(["PIN?","at+cpin?"])
        allActionsItemList.append(["AT", "AT"])
        allActionsItemList.append(["Model","at^siekret=1"])
        allActionsItemList.append(["Shutdown","at^smso"])

        for actionItem in allActionsItemList:
            newActionObject = self.createAction(actionItem[0], actionItem[1])
            self.actionGroup.addAction(newActionObject)
            self.fileToolBar.addAction(newActionObject)

    def selectScenario(self, sequenceName):
        QtCore.qDebug("Hello From SelectScenario")
        QtCore.qDebug(sequenceName)
        self.commands = deepcopy(SequenceFactory().getSequence(sequenceName))
        self.currentCmd = 0
        self.lineEdit.setText(self.commands[0])

    def closeEvent(self, event):
        self.writeSettings()
        
    def readSettings(self):
        settings = QtCore.QSettings("REC", "MiniYatt")
        pos = settings.value("pos", QtCore.QPoint(200, 200))
        size = settings.value("size", QtCore.QSize(400, 400))
        self.resize(size)
        self.move(pos)

    def writeSettings(self):
        settings = QtCore.QSettings("REC", "MiniYatt")
        settings.setValue("pos", self.pos())
        settings.setValue("size", self.size())

    def openFile(self):
        QtCore.qDebug("Hello From Open FIle")

    def addButton(self):
        self.addButtonWidget = AddButtonWidget()
        self.addButtonWidget.setWindowModality(QtCore.Qt.ApplicationModal)
        self.addButtonWidget.resize(200,200)
        self.addButtonWidget.show()
        QtCore.qDebug("Hello From Add Button")

    def readNewData(self, data):
        data = data.strip()
        self.textEdit.append(data)
        self.textEdit.moveCursor(QtGui.QTextCursor.End)
        
        if self.mode == Mode.PEGASUS_MODE:
            self.sequencePlayer(data)

    def timeout(self):
        QtCore.qDebug("TIMEOUT!")

    def sequencePlayer(self, data):
        #TODO - poprawic indeksy
        ### Sprawdz, czy dostales oczekiwane dane 
        
        QtCore.qDebug("JESTEM w sequencePlayer")
        QtCore.qDebug(repr(self.response))
        QtCore.qDebug(data)
        
        if data.find(self.response[0]) >= 0 :
            if len(self.response) == 1:
                self.timer.cancel()
                waitBeforeNext = self.commands[self.currentCmd].waitBeforeNext
                self.currentCmd += 1

                #TRZEBA USTAWIC WSZYSTKIE PARAMETRY DLA NOWEJ KOMENDY
                #wysylamy i zapominamy - nasluchujemy na odpowiedzi tutaj.
                self.nextMsg = self.commands[self.currentCmd].cmd
                self.timeoutValue = self.commands[self.currentCmd].timeout
                self.response = self.commands[self.currentCmd].response

                self.timerWaitBeforeNext = Timer(waitBeforeNext, self.sendNext)
                self.timerWaitBeforeNext.start()
            else:
                self.response.pop(0)
        else:
            QtCore.qDebug("IGNORE")

    def sendDataMsg(self, msg):
        #msg = self.lineEdit.text()
        QtCore.qDebug("JESTEM W SendDataMsg: " + msg)
        self.socket.write(str.encode(msg) + b"\r\n")

        if self.mode == Mode.MANUAL_PLAYER_MODE:
            self.currentCmd += 1
            self.lineEdit.setText(self.commands[self.currentCmd])
        else:
            #addHistory(msg)
            self.lineEdit.setText("")

    def sendNext(self):
        self.sendDataMsg(self.nextMsg)
        self.timer = Timer(self.timeoutValue, self.timeout)
        self.timer.start()

    def sendData(self):
        QtCore.qDebug("sendData odpalone!")
        self.sendDataMsg(self.lineEdit.text())

    def actionGroupTriggered(self, action):
        QtCore.qDebug("Hello from actionGroupTriggered")
        QtCore.qDebug(action.data())
        self.socket.write(str.encode(action.data()) + b"\r\n")