Пример #1
0
    def highlightTab(self):
        currentPane = self._splitpane
        previousPane = currentPane
        while currentPane and not isinstance(currentPane, JTabbedPane):
            previousPane = currentPane
            currentPane = currentPane.getParent()
        if currentPane:
            index = currentPane.indexOfComponent(previousPane)
            currentPane.setBackgroundAt(index, Color(0xff6633))

            class setColorBackActionListener(ActionListener):
                def actionPerformed(self, e):
                    currentPane.setBackgroundAt(index, Color.BLACK)

            timer = Timer(5000, setColorBackActionListener())
            timer.setRepeats(False)
            timer.start()
Пример #2
0
class CommandClient():
    def __init__(self, extender):
        self._syncTimer = Timer(1000, None)
        self._syncTimer.setRepeats(True)
        self._syncTimer.actionPerformed = self._sendCommandSync
        self._syncTimer.stop()

        self.commandListenPort = 8089;

        self._startTimer = Timer(1000, None)
        self._startTimer.setInitialDelay(1500)
        self._startTimer.setRepeats(False)
        self._startTimer.actionPerformed = self._sendCommandStart
        self._startTimer.stop()

        self._extender = extender

    def startCrawling(self):
        self._startTimer.start()
    def startSync(self):
        self._syncTimer.start()

    def stopCrawling(self):
        self._sendCommandStop(None)
        self._syncTimer.stop()

    def _sendCommandStart(self, ev):
        self._sendCommand("start")
        self.startSync()

    def _sendCommandStop(self, ev):
        self._sendCommand("stop")

    def _sendCommandSync(self, ev):
        result = self._sendCommand("sync")
        self._extender.syncCrawlingState(result)

    def _sendCommand(self, command):
        url = 'http://127.0.0.1:' + str(self.commandListenPort) + '/?command={0}'.format(command)
        # TODO: iterate through parameters

        response =  urllib2.urlopen(url)
        data = json.load(response)
        return data
Пример #3
0
    class TrackDevice(java.beans.PropertyChangeListener):
        import java
        import javax.swing
        import javax.swing.Timer

        delayTimer = None
        relayClicks = None

        # TrackDevice.init - Initialize a TrackDevice instance for a particular device
        #
        # aName          : Device name
        # aDevice        : JMRI device instance
        # aAllowedStates : Array of states we want to track, other states are ignored
        #
        def init(self, aName, aDevice, aAllowedStates, aLogFile, aParent):
            from javax.swing import Timer
            #print ('TrackDevice.init ' + aName )
            self.DeviceName = aName
            self.Device = aDevice
            self.DeviceValue = self.Device.getValue()
            self.AllowedStates = aAllowedStates
            self.parent = aParent
            self.LogFile = aLogFile

            self.timeoutListener = self.TimeoutReceiver()
            self.timeoutListener.setCallBack(self.receiveTimeoutHandler)
            self.receiveTimer = Timer(1, self.timeoutListener)
            self.receiveTimer.stop()
            self.receiveTimer.setRepeats(False)

            self.sendTimeoutListener = self.TimeoutReceiver()
            self.sendTimeoutListener.setCallBack(self.sendTimeoutHandler)
            self.sendTimer = Timer(1, self.sendTimeoutListener)
            self.sendTimer.stop()
            self.sendTimer.setRepeats(False)

            self.pauseTimeoutListener = self.TimeoutReceiver()
            self.pauseTimeoutListener.setCallBack(self.pauseTimeoutHandler)
            self.pauseTimer = Timer(1, self.pauseTimeoutListener)
            self.pauseTimer.stop()
            self.pauseTimer.setRepeats(False)

            self.relayClicks = jmri.jmrit.Sound(
                "resources/sounds/Code-receive.wav")
            #self.relayClicks = jmri.jmrit.Sound(jmri.util.FileUtil.getExternalFilename("preference:resources/sounds/EnhancedCTCRelay.wav"))
            self.relaySend = jmri.jmrit.Sound("resources/sounds/Code-send.wav")

            return

        # TrackDevice.updateState - Track the device state while reading the old log
        #                           file.  Note the state but don't change the device
        #                           itself and don't log the changes to the new log file
        #                           (yet).
        #
        # aNewState : New device state.
        #
        def updateState(self, aNewState):
            #print 'updateState ' + self.DeviceName
            for i in range(len(self.AllowedStates)):
                if (aNewState == self.AllowedStates[i]):
                    self.DeviceValue = aNewState
                    break

        # TrackDevice.propertyChange - Record state changes as a result of activities
        #                              elsewhere in JMRI
        #
        # aEvent : Event triggering the change (we don't actually look at the event...)
        #
        def propertyChange(self, aEvent):
            #print "Property change " + self.DeviceName
            newValue = self.Device.getValue()

            codeSendSensor = sensors.getSensor("IS16:CCK")
            codeSendSensor.setState(ACTIVE)

            self.relaySend.loop()
            ccdl = 5 + java.util.Random().nextInt(1)  # Code transmission delay
            self.sendTimer.setInitialDelay(ccdl * 10)
            self.sendTimer.start()

            if (newValue == self.DeviceValue):
                return

            for i in range(len(self.AllowedStates)):
                if (newValue == self.AllowedStates[i]):
                    self.DeviceValue = newValue
                    #logStateChange2(self.DeviceName, self.DeviceValue, True)
                    #print "state change " + self.DeviceName + " " + str(self.DeviceValue)
                    self.LogFile.write(self.DeviceName + " " +
                                       self.DeviceValue + "\n")
                    self.LogFile.flush()
                    break
            return

        # TrackDevice.setInitialDeviceState - After reading all of the old tracking file we
        #                                     now initialize the actual devices to their last
        #                                     known states and log these states into the new
        #                                     log file.
        #
        def setInitialDeviceState(self, logFile):
            #       Uncomment the following print statement to display the list of devices being tracked.
            #print "In setInitDeviceState, name = " + self.DeviceName + " value = " + self.DeviceValue
            self.LogFile = logFile
            self.Device.setValue(self.DeviceValue)
            self.Device.addPropertyChangeListener(self)
            #logStateChange2(self.DeviceName, self.DeviceState, False)
            logFile.write(self.DeviceName + " " + self.DeviceValue + "\n")

            signalId = "IS" + self.DeviceName[2:3]
            ctcId = "CTC:TO" + self.DeviceName[2:3]
            # Move the switch lever to the correct position
            if (self.DeviceValue == "P"):

                #print " ctcId = " + ctcId + " state = green"
                turnouts.provideTurnout("NT" +
                                        self.DeviceName[2:3]).setState(CLOSED)
                sensors.getSensor(signalId + ":WLL").setState(INACTIVE)
                sensors.getSensor(signalId + ":WLR").setState(INACTIVE)
                sensors.getSensor(signalId + ":WLC").setState(ACTIVE)

                sensors.getSensor(signalId + ":WKR").setState(INACTIVE)
                sensors.getSensor(signalId + ":WKL").setState(INACTIVE)
                sensors.getSensor(signalId + ":WKC").setState(ACTIVE)

                sensors.getSensor(ctcId + "GK").setState(ACTIVE)
                sensors.getSensor(ctcId + "YK").setState(INACTIVE)
                sensors.getSensor(ctcId + "RK").setState(INACTIVE)

                sensors.getSensor(ctcId + "GS").setState(ACTIVE)
                sensors.getSensor(ctcId + "YS").setState(INACTIVE)
                sensors.getSensor(ctcId + "RS").setState(INACTIVE)

                sensors.getSensor(signalId + ":TOC").setState(INACTIVE)
                sensors.getSensor(signalId + ":TOS").setState(INACTIVE)
                sensors.getSensor(signalId + ":TOP").setState(ACTIVE)
            elif (self.DeviceValue == "C"):
                #print " ctcId = " + ctcId + " state = yellow"
                sensors.getSensor(signalId + ":WLL").setState(ACTIVE)
                sensors.getSensor(signalId + ":WLR").setState(INACTIVE)
                sensors.getSensor(signalId + ":WLC").setState(INACTIVE)
                sensors.getSensor(signalId + ":WKR").setState(INACTIVE)
                sensors.getSensor(signalId + ":WKL").setState(ACTIVE)
                sensors.getSensor(signalId + ":WKC").setState(INACTIVE)

                sensors.getSensor(ctcId + "GK").setState(INACTIVE)
                sensors.getSensor(ctcId + "YK").setState(ACTIVE)
                sensors.getSensor(ctcId + "RK").setState(INACTIVE)

                sensors.getSensor(ctcId + "GS").setState(INACTIVE)
                sensors.getSensor(ctcId + "YS").setState(ACTIVE)
                sensors.getSensor(ctcId + "RS").setState(INACTIVE)

                sensors.getSensor(signalId + ":TOC").setState(ACTIVE)
                sensors.getSensor(signalId + ":TOS").setState(INACTIVE)
                sensors.getSensor(signalId + ":TOP").setState(INACTIVE)

            else:
                #print " ctcId = " + ctcId + " state = red"
                turnouts.provideTurnout("NT" +
                                        self.DeviceName[2:3]).setState(THROWN)
                sensors.getSensor(signalId + ":WLL").setState(INACTIVE)
                sensors.getSensor(signalId + ":WLR").setState(ACTIVE)
                sensors.getSensor(signalId + ":WLC").setState(INACTIVE)
                sensors.getSensor(signalId + ":WKR").setState(ACTIVE)
                sensors.getSensor(signalId + ":WKL").setState(INACTIVE)
                sensors.getSensor(signalId + ":WKC").setState(INACTIVE)

                sensors.getSensor(ctcId + "GK").setState(INACTIVE)
                sensors.getSensor(ctcId + "YK").setState(INACTIVE)
                sensors.getSensor(ctcId + "RK").setState(ACTIVE)

                sensors.getSensor(ctcId + "GS").setState(INACTIVE)
                sensors.getSensor(ctcId + "YS").setState(INACTIVE)
                sensors.getSensor(ctcId + "RS").setState(ACTIVE)

                sensors.getSensor(signalId + ":TOC").setState(INACTIVE)
                sensors.getSensor(signalId + ":TOS").setState(ACTIVE)
                sensors.getSensor(signalId + ":TOP").setState(INACTIVE)

        class TimeoutReceiver(java.awt.event.ActionListener):
            cb = None

            def actionPerformed(self, event):
                if (self.cb != None):
                    self.cb(event)
                return

            def setCallBack(self, cbf):
                self.cb = cbf
                return

        class TimeoutReceiver2(java.awt.event.ActionListener):
            cb = None

            def actionPerformed(self, event):
                if (self.cb != None):
                    self.cb(event)
                return

            def setCallBack(self, cbf):
                self.cb = cbf
                return

        class TimeoutReceiver3(java.awt.event.ActionListener):
            cb = None

            def actionPerformed(self, event):
                if (self.cb != None):
                    self.cb(event)
                return

            def setCallBack(self, cbf):
                self.cb = cbf
                return

        def sendTimeoutHandler(self, event):
            #print "In send timeout handler"
            self.sendTimer.stop()
            self.relaySend.stop()
            sensors.getSensor("IS16:CCK").setState(INACTIVE)

            #sleep(2)

            signalNumber = self.DeviceName[2:3]
            if (self.Device.getValue() == "P"):
                turnouts.provideTurnout("NT" + signalNumber).setState(CLOSED)
            elif (self.Device.getValue() == "S"):
                turnouts.provideTurnout("NT" + signalNumber).setState(THROWN)

            smdl = 5 + java.util.Random().nextInt(2)  # Switch motor delay -

            self.pauseTimer.setInitialDelay(smdl * 10)
            self.pauseTimer.start()
            return

        def pauseTimeoutHandler(self, event):
            #print "In pause timeout handler"
            self.pauseTimer.stop()

            sensors.getSensor("IS17:ICK").setState(ACTIVE)
            #print "Turning on IC light"

            self.relayClicks.loop()
            newName = "IS" + self.DeviceName[2:3]
            sensors.getSensor(newName + ":WKC").setState(INACTIVE)
            sensors.getSensor(newName + ":WKL").setState(INACTIVE)
            sensors.getSensor(newName + ":WKR").setState(INACTIVE)

            ctcName = "CTC:TO" + self.DeviceName[2:3]
            if (sensors.getSensor(ctcName + "YK").getState() == ACTIVE):
                sensors.getSensor(ctcName + "YK").setState(INACTIVE)
            if (sensors.getSensor(ctcName + "GK").getState() == ACTIVE):
                sensors.getSensor(ctcName + "GK").setState(INACTIVE)
            if (sensors.getSensor(ctcName + "RK").getState() == ACTIVE):
                sensors.getSensor(ctcName + "RK").setState(INACTIVE)

            icdl = 5 + java.util.Random().nextInt(3)  # Indicator code delay

            self.receiveTimer.setInitialDelay(icdl * 10)
            self.receiveTimer.start()
            return

        def receiveTimeoutHandler(self, event):
            # see which phase we think we are in
            #print "In receive timeout Handler"
            self.receiveTimer.stop()

            signalNumber = self.DeviceName[2:3]
            #print " Signal number = " + str(signalNumber) + " signal state = " + self.Device.getValue()
            if (self.Device.getValue() == "P"):
                sensors.getSensor("IS" + signalNumber +
                                  ":WKC").setState(ACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":WKR").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":WKL").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":TOC").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":TOS").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":TOP").setState(ACTIVE)

                #sensors.getSensor("CTC:TO" + signalNumber + "YK").setState(INACTIVE)
                sensors.getSensor("CTC:TO" + signalNumber +
                                  "GK").setState(ACTIVE)
                #sensors.getSensor("CTC:TO" + signalNumber + "RK").setState(INACTIVE)

            elif (self.Device.getValue() == "C"):
                sensors.getSensor("IS" + signalNumber +
                                  ":WKC").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":WKR").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":WKL").setState(ACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":TOS").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":TOP").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":TOC").setState(ACTIVE)

                sensors.getSensor("CTC:TO" + signalNumber +
                                  "YK").setState(ACTIVE)
                #sensors.getSensor("CTC:TO" + signalNumber + "GK").setState(INACTIVE)
                #sensors.getSensor("CTC:TO" + signalNumber + "RK").setState(INACTIVE)
                jmri.jmrit.Sound("resources/sounds/Bell.wav").play()
            elif (self.Device.getValue() == "S"):
                sensors.getSensor("IS" + signalNumber +
                                  ":WKC").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":WKR").setState(ACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":WKL").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":TOC").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":TOP").setState(INACTIVE)
                sensors.getSensor("IS" + signalNumber +
                                  ":TOS").setState(ACTIVE)

                #sensors.getSensor("CTC:TO" + signalNumber + "YK").setState(INACTIVE)
                #sensors.getSensor("CTC:TO" + signalNumber + "GK").setState(INACTIVE)
                sensors.getSensor("CTC:TO" + signalNumber +
                                  "RK").setState(ACTIVE)

            self.relayClicks.stop()
            self.parent.waitMsec(1000)
            sensors.getSensor("IS17:ICK").setState(INACTIVE)

            return
Пример #4
0
class USBThrottle(Jynstrument, PropertyChangeListener, AddressListener):
    #Property listener part: USB value
    def propertyChange(self, event):
        # Customize bellow for throttles calls:
        if (event.propertyName == "Value"):  # USB
            if (event.oldValue.getController() == self.desiredController):
                component = event.oldValue.getComponent().toString()
                value = event.newValue
                # Uncomment bellow line to see component name and its value
                # print "Component",component,"value changed to",value
                try:
                    # Change current ThrottleFrame
                    if ((component == self.driver.componentNextThrottleFrame)
                            and
                        (value == self.driver.valueNextThrottleFrame)):  #NEXT
                        self.getContext().nextThrottleFrame()
                    if ((component
                         == self.driver.componentPreviousThrottleFrame) and
                        (value == self.driver.valuePreviousThrottleFrame)
                        ):  #PREVIOUS
                        self.getContext().previousThrottleFrame()
                    if ((component
                         == self.driver.componentNextRunningThrottleFrame) and
                        (value == self.driver.valueNextRunningThrottleFrame)
                        ):  #NEXT RUNNING
                        self.getContext().nextRunningThrottleFrame()
                    if ((component
                         == self.driver.componentPreviousRunningThrottleFrame)
                            and
                        (value == self.driver.valuePreviousRunningThrottleFrame
                         )):  #PREVIOUS RUNNING
                        self.getContext().previousRunningThrottleFrame()
                except AttributeError:
                    pass

                if (self.throttle == None):
                    try:
                        # Browse through roster
                        if ((component
                             == self.driver.componentNextRosterBrowse) and
                            (value == self.driver.valueNextRoster)):  #NEXT
                            selectedIndex = self.addressPanel.getRosterSelectedIndex(
                            )
                            self.addressPanel.setVisible(True)
                            self.addressPanel.setIcon(False)
                            self.addressPanel.setRosterSelectedIndex(
                                selectedIndex + 1)
                        if ((component
                             == self.driver.componentPreviousRosterBrowse) and
                            (value
                             == self.driver.valuePreviousRoster)):  #PREVIOUS
                            selectedIndex = self.addressPanel.getRosterSelectedIndex(
                            )
                            self.addressPanel.setVisible(True)
                            self.addressPanel.setIcon(False)
                            self.addressPanel.setRosterSelectedIndex(
                                selectedIndex - 1)
                    except AttributeError:
                        pass
                    try:
                        # Request a throttle
                        if ((component == self.driver.componentRosterSelect)
                                and (value == self.driver.valueRosterSelect)):
                            self.addressPanel.selectRosterEntry()
                    except AttributeError:
                        pass

                # From there; current throttle control, hence require a throttle
                if (self.throttle != None):
                    # Release current throttle
                    try:
                        if ((component == self.driver.componentThrottleRelease)
                                and
                            (value == self.driver.valueThrottleRelease)):
                            self.addressPanel.dispatchAddress()
                    except AttributeError:
                        pass

                    try:
                        # Speed - dynamic controler (joystick going back to neutral position)
                        if ((component == self.driver.componentSpeedIncrease)
                                or
                            (component == self.driver.componentSpeedDecrease)
                                or (component == self.driver.componentSpeed)):
                            if ((component
                                 == self.driver.componentSpeedIncrease) and
                                (value == self.driver.valueSpeedIncrease)):
                                self.speedAction.setSpeedIncrement(0.03)
                            if ((component
                                 == self.driver.componentSpeedDecrease) and
                                (value == self.driver.valueSpeedDecrease)):
                                self.speedAction.setSpeedIncrement(-0.03)
                            if (component == self.driver.componentSpeed):
                                try:
                                    self.vsd = valueSpeedDivider * self.driver.componentSpeedMultiplier
                                except AttributeError:
                                    self.vsd = valueSpeedDivider
                                self.speedAction.setSpeedIncrement(value /
                                                                   self.vsd)
                            if (abs(value) > self.driver.valueSpeedTrigger):
                                self.speedTimer.start()
                            else:
                                self.speedTimer.stop()
                    except AttributeError:
                        self.speedTimer.stop(
                        )  # just in case, stop it, really should never get there

                    try:
                        # Speed v2 - static controler (lever on RailDriver or AAR105)
                        if (component == self.driver.componentSpeedSet):
                            # negative is lever front, positive is lever back
                            # limit range to only positive side of lever
                            if (value < self.driver.valueSpeedSetMinValue):
                                value = self.driver.valueSpeedSetMinValue
                            if (value > self.driver.valueSpeedSetMaxValue):
                                value = self.driver.valueSpeedSetMaxValue
                            # convert fraction of input to speed step
                            self.throttle.setSpeedSetting(
                                (value - self.driver.valueSpeedSetMinValue) /
                                (self.driver.valueSpeedSetMaxValue -
                                 self.driver.valueSpeedSetMinValue))
                            print "Slider Speed:", self.controlPanel.getDisplaySlider(
                            )
                    except AttributeError:
                        pass
                    # Direction
                    try:
                        if ((component
                             == self.driver.componentDirectionForward) and
                            (value == self.driver.valueDirectionForward)):
                            self.throttle.setIsForward(True)
                        if ((component
                             == self.driver.componentDirectionBackward) and
                            (value == self.driver.valueDirectionBackward)):
                            self.throttle.setIsForward(False)
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentDirectionSwitch)
                                and
                            (value == self.driver.valueDirectionSwitch)):
                            self.throttle.setIsForward(
                                not self.throttle.getIsForward())
                    except AttributeError:
                        pass

                    # Speed presets
                    try:  # STOP
                        if ((component == self.driver.componentStopSpeed)
                                and (value == self.driver.valueStopSpeed)):
                            if (Calendar.getInstance().getTimeInMillis() -
                                    self.lastTimeStopButton < delay4doubleTap):
                                self.throttle.setSpeedSetting(
                                    EStopSpeed)  # EStop on double tap
                            else:
                                self.throttle.setSpeedSetting(speedStopSpeed)
                            self.lastTimeStopButton = Calendar.getInstance(
                            ).getTimeInMillis()
                    except AttributeError:
                        pass
                    try:  # EStop
                        if ((component == self.driver.componentEStopSpeed)
                                and (value == self.driver.valueEStopSpeed)):
                            self.throttle.setSpeedSetting(EStopSpeed)
                    except AttributeError:
                        pass
                    try:  # EStop
                        if ((component == self.driver.componentEStopSpeedBis)
                                and (value == self.driver.valueEStopSpeedBis)):
                            self.throttle.setSpeedSetting(EStopSpeed)
                    except AttributeError:
                        pass
                    try:  # SLOW
                        if ((component == self.driver.componentSlowSpeed)
                                and (value == self.driver.valueSlowSpeed)):
                            self.throttle.setSpeedSetting(speedSlowSpeed)
                    except AttributeError:
                        pass
                    try:  # CRUISE
                        if ((component == self.driver.componentCruiseSpeed)
                                and (value == self.driver.valueCruiseSpeed)):
                            if (Calendar.getInstance().getTimeInMillis() -
                                    self.lastTimeCruiseButton <
                                    delay4doubleTap):  # EStop on double tap
                                self.throttle.setSpeedSetting(
                                    speedMaxSpeed)  # Max speed on double tap
                            else:
                                self.throttle.setSpeedSetting(speedCruiseSpeed)
                            self.lastTimeCruiseButton = Calendar.getInstance(
                            ).getTimeInMillis()
                    except AttributeError:
                        pass
                    try:  # MAX
                        if ((component == self.driver.componentMaxSpeed)
                                and (value == self.driver.valueMaxSpeed)):
                            self.throttle.setSpeedSetting(speedMaxSpeed)
                    except AttributeError:
                        pass

                    # Functions
                    try:
                        if ((component == self.driver.componentF0)
                                and (value == self.driver.valueF0)):
                            self.throttle.setF0(not self.throttle.getF0())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(0))
                                and (component == self.driver.componentF0)
                                and (value == self.driver.valueF0Off)):
                            self.throttle.setF0(not self.throttle.getF0())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF1)
                                and (value == self.driver.valueF1)):
                            self.throttle.setF1(not self.throttle.getF1())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(1))
                                and (component == self.driver.componentF1)
                                and (value == self.driver.valueF1Off)):
                            self.throttle.setF1(not self.throttle.getF1())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF2)
                                and (value == self.driver.valueF2)):
                            self.throttle.setF2(not self.throttle.getF2())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(2))
                                and (component == self.driver.componentF2)
                                and (value == self.driver.valueF2Off)):
                            self.throttle.setF2(not self.throttle.getF2())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF3)
                                and (value == self.driver.valueF3)):
                            self.throttle.setF3(not self.throttle.getF3())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(3))
                                and (component == self.driver.componentF3)
                                and (value == self.driver.valueF3Off)):
                            self.throttle.setF3(not self.throttle.getF3())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF4)
                                and (value == self.driver.valueF4)):
                            self.throttle.setF4(not self.throttle.getF4())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(4))
                                and (component == self.driver.componentF4)
                                and (value == self.driver.valueF4Off)):
                            self.throttle.setF4(not self.throttle.getF4())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF5)
                                and (value == self.driver.valueF5)):
                            self.throttle.setF5(not self.throttle.getF5())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(5))
                                and (component == self.driver.componentF5)
                                and (value == self.driver.valueF5Off)):
                            self.throttle.setF5(not self.throttle.getF5())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF6)
                                and (value == self.driver.valueF6)):
                            self.throttle.setF6(not self.throttle.getF6())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(6))
                                and (component == self.driver.componentF6)
                                and (value == self.driver.valueF6Off)):
                            self.throttle.setF6(not self.throttle.getF6())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF7)
                                and (value == self.driver.valueF7)):
                            self.throttle.setF7(not self.throttle.getF7())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(7))
                                and (component == self.driver.componentF7)
                                and (value == self.driver.valueF7Off)):
                            self.throttle.setF7(not self.throttle.getF7())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF8)
                                and (value == self.driver.valueF8)):
                            self.throttle.setF8(not self.throttle.getF8())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(8))
                                and (component == self.driver.componentF8)
                                and (value == self.driver.valueF8Off)):
                            self.throttle.setF8(not self.throttle.getF8())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF9)
                                and (value == self.driver.valueF9)):
                            self.throttle.setF9(not self.throttle.getF9())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(9))
                                and (component == self.driver.componentF9)
                                and (value == self.driver.valueF9Off)):
                            self.throttle.setF9(not self.throttle.getF9())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF10)
                                and (value == self.driver.valueF10)):
                            self.throttle.setF10(not self.throttle.getF10())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(10))
                                and (component == self.driver.componentF10)
                                and (value == self.driver.valueF10Off)):
                            self.throttle.setF10(not self.throttle.getF10())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF11)
                                and (value == self.driver.valueF11)):
                            self.throttle.setF11(not self.throttle.getF11())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(11))
                                and (component == self.driver.componentF11)
                                and (value == self.driver.valueF11Off)):
                            self.throttle.setF11(not self.throttle.getF11())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF12)
                                and (value == self.driver.valueF12)):
                            self.throttle.setF12(not self.throttle.getF12())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(12))
                                and (component == self.driver.componentF12)
                                and (value == self.driver.valueF12Off)):
                            self.throttle.setF12(not self.throttle.getF12())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF13)
                                and (value == self.driver.valueF13)):
                            self.throttle.setF13(not self.throttle.getF13())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(13))
                                and (component == self.driver.componentF13)
                                and (value == self.driver.valueF13Off)):
                            self.throttle.setF13(not self.throttle.getF13())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF14)
                                and (value == self.driver.valueF14)):
                            self.throttle.setF14(not self.throttle.getF14())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(14))
                                and (component == self.driver.componentF14)
                                and (value == self.driver.valueF14Off)):
                            self.throttle.setF14(not self.throttle.getF14())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF15)
                                and (value == self.driver.valueF15)):
                            self.throttle.setF15(not self.throttle.getF15())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(15))
                                and (component == self.driver.componentF15)
                                and (value == self.driver.valueF15Off)):
                            self.throttle.setF15(not self.throttle.getF15())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF16)
                                and (value == self.driver.valueF16)):
                            self.throttle.setF16(not self.throttle.getF16())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(16))
                                and (component == self.driver.componentF16)
                                and (value == self.driver.valueF16Off)):
                            self.throttle.setF16(not self.throttle.getF16())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF17)
                                and (value == self.driver.valueF17)):
                            self.throttle.setF17(not self.throttle.getF17())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(17))
                                and (component == self.driver.componentF17)
                                and (value == self.driver.valueF17Off)):
                            self.throttle.setF17(not self.throttle.getF17())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF18)
                                and (value == self.driver.valueF18)):
                            self.throttle.setF18(not self.throttle.getF18())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(18))
                                and (component == self.driver.componentF18)
                                and (value == self.driver.valueF18Off)):
                            self.throttle.setF18(not self.throttle.getF18())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF19)
                                and (value == self.driver.valueF19)):
                            self.throttle.setF19(not self.throttle.getF19())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(19))
                                and (component == self.driver.componentF19)
                                and (value == self.driver.valueF19Off)):
                            self.throttle.setF19(not self.throttle.getF19())
                    except AttributeError:
                        pass

                    try:
                        if ((component == self.driver.componentF20)
                                and (value == self.driver.valueF20)):
                            self.throttle.setF20(not self.throttle.getF20())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(20))
                                and (component == self.driver.componentF20)
                                and (value == self.driver.valueF20Off)):
                            self.throttle.setF20(not self.throttle.getF20())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF21)
                                and (value == self.driver.valueF21)):
                            self.throttle.setF21(not self.throttle.getF21())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(21))
                                and (component == self.driver.componentF21)
                                and (value == self.driver.valueF21Off)):
                            self.throttle.setF21(not self.throttle.getF21())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF22)
                                and (value == self.driver.valueF22)):
                            self.throttle.setF22(not self.throttle.getF22())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(22))
                                and (component == self.driver.componentF22)
                                and (value == self.driver.valueF22Off)):
                            self.throttle.setF22(not self.throttle.getF22())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF23)
                                and (value == self.driver.valueF23)):
                            self.throttle.setF23(not self.throttle.getF23())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(23))
                                and (component == self.driver.componentF23)
                                and (value == self.driver.valueF23Off)):
                            self.throttle.setF23(not self.throttle.getF23())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF24)
                                and (value == self.driver.valueF24)):
                            self.throttle.setF24(not self.throttle.getF24())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(24))
                                and (component == self.driver.componentF24)
                                and (value == self.driver.valueF24Off)):
                            self.throttle.setF24(not self.throttle.getF24())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF25)
                                and (value == self.driver.valueF25)):
                            self.throttle.setF25(not self.throttle.getF25())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(25))
                                and (component == self.driver.componentF25)
                                and (value == self.driver.valueF25Off)):
                            self.throttle.setF25(not self.throttle.getF25())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF26)
                                and (value == self.driver.valueF26)):
                            self.throttle.setF26(not self.throttle.getF26())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(26))
                                and (component == self.driver.componentF26)
                                and (value == self.driver.valueF26Off)):
                            self.throttle.setF26(not self.throttle.getF26())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF27)
                                and (value == self.driver.valueF27)):
                            self.throttle.setF27(not self.throttle.getF27())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(27))
                                and (component == self.driver.componentF27)
                                and (value == self.driver.valueF27Off)):
                            self.throttle.setF27(not self.throttle.getF27())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF28)
                                and (value == self.driver.valueF28)):
                            self.throttle.setF28(not self.throttle.getF28())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(28))
                                and (component == self.driver.componentF28)
                                and (value == self.driver.valueF28Off)):
                            self.throttle.setF28(not self.throttle.getF28())
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF29)
                                and (value == self.driver.valueF29)):
                            self.throttle.setF29(not self.throttle.getF29())
                        if ((self.roster != None)
                                and (not self.roster.getFunctionLockable(29))
                                and (component == self.driver.componentF29)
                                and (value == self.driver.valueF29Off)):
                            self.throttle.setF29(not self.throttle.getF29())
                    except AttributeError:
                        pass

        # Nothing to customize bellow this point
        if (event.propertyName == "ThrottleFrame"
            ):  # Current throttle frame changed
            self.speedTimer.stop()
            event.oldValue.getAddressPanel().removeAddressListener(self)
            self.addressPanel = event.newValue.getAddressPanel()
            self.throttle = self.addressPanel.getThrottle()
            self.roster = self.addressPanel.getRosterEntry()
            self.speedAction.setThrottle(self.throttle)
            event.newValue.getAddressPanel().addAddressListener(self)

#Jynstrument main and mandatory methods

    def getExpectedContextClassName(self):
        return "jmri.jmrit.throttle.ThrottleWindow"

    def init(self):
        self.getContext().addPropertyChangeListener(
            self)  #ThrottleFrame change
        self.getContext().getCurrentThrottleFrame().getAddressPanel(
        ).addAddressListener(self)  # change of throttle in Current frame
        self.addressPanel = self.getContext().getCurrentThrottleFrame(
        ).getAddressPanel()
        self.throttle = self.addressPanel.getThrottle()  # the throttle
        self.roster = self.addressPanel.getRosterEntry()  # roster entry if any
        self.speedAction = SpeedAction()  #Speed increase thread
        self.speedAction.setThrottle(self.throttle)
        self.speedTimer = Timer(
            valueSpeedTimerRepeat, self.speedAction
        )  # Very important to use swing Timer object (see Swing and multithreading doc)
        self.speedTimer.setRepeats(True)
        self.label = JButton(
            ImageIcon(self.getFolder() + "/USBControl.png",
                      "USBThrottle"))  #label
        self.label.addMouseListener(
            self.getMouseListeners()
            [0])  # In order to get the popupmenu on the button too
        self.add(self.label)
        self.model = jmri.jmrix.jinput.TreeModel.instance()  # USB
        self.desiredController = None
        self.ctrlMenuItem = []
        self.USBDriver = None
        self.driver = None
        mi = JCheckBoxMenuItem("None")
        self.getPopUpMenu().add(mi)
        mi.addItemListener(ControllerItemListener(None, self))
        self.ctrlMenuItem.append(mi)
        for ctrl in self.model.controllers():
            mi = JCheckBoxMenuItem(ctrl.getName())
            self.getPopUpMenu().add(mi)
            mi.addItemListener(ControllerItemListener(ctrl, self))
            self.ctrlMenuItem.append(mi)
        if (len(self.ctrlMenuItem) == 0):
            print "No matching USB device found"
        else:
            self.ctrlMenuItem[0].setSelected(
                True)  # by default connect to the first one
        self.model.addPropertyChangeListener(self)
        self.lastTimeStopButton = Calendar.getInstance().getTimeInMillis()
        self.lastTimeCruiseButton = Calendar.getInstance().getTimeInMillis()

# On quit clean up resources

    def quit(self):
        self.speedTimer.stop()
        for mi in self.ctrlMenuItem:
            self.getPopUpMenu().remove(mi)
        self.ctrlMenuItem = None
        self.speedAction = None
        self.speedTimer = None
        self.throttle = None
        self.addressPanel = None
        self.driver = None
        self.USBDriver = None
        self.getContext().removePropertyChangeListener(self)
        self.model.removePropertyChangeListener(self)
        self.getContext().getCurrentThrottleFrame().getAddressPanel(
        ).removeAddressListener(self)

# Menu entry changed for Current controller and update driver

    def setSelectedController(self, ctrl, item):
        for mi in self.ctrlMenuItem:
            if (mi != item):  # Force deselection of other ones
                mi.setSelected(False)
        self.desiredController = ctrl
        if (ctrl != None):
            sys.path.append(self.getFolder())  # Load a driver
            try:
                del self.driver
                del self.USBDriver
                dd = ctrl.getName()
                dd = dd.replace(" ", "")
                dd = dd.replace(".", "")
                dd = dd.replace("(", "")
                dd = dd.replace(")", "")
                dd = dd.replace("{", "")
                dd = dd.replace("}", "")
                dd = dd.replace("[", "")
                dd = dd.replace("]", "")
                self.USBDriver = __import__(dd)
            except ImportError:  # On error load a default one
                print "Driver \"" + dd + "\" not found in \"" + self.getFolder(
                ) + "\", loading default one"
                self.USBDriver = __import__("Default")
            reload(self.USBDriver)
            sys.path.remove(self.getFolder())
            self.driver = self.USBDriver.USBDriver()

    def setXml(self, elt):
        if (elt.getChildren("USBThrottle") == None):
            return
        ctrl = elt.getChildren("USBThrottle")[0].getAttributeValue(
            "DesiredController")
        if (ctrl == None):
            return
        for mi in self.ctrlMenuItem:
            if (mi.getText() == ctrl):
                mi.setSelected(True)
                break

    def getXml(self):
        elt = Element("USBThrottle")
        for mi in self.ctrlMenuItem:
            if (mi.isSelected()):
                elt.setAttribute("DesiredController", mi.getText())
                break
        return elt

#AddressListener part: to listen for address changes in address panel (release, acquired)

    def notifyAddressChosen(self, address):
        pass

    def notifyAddressThrottleFound(self, throttle):
        self.speedTimer.stop()
        self.throttle = throttle
        self.speedAction.setThrottle(self.throttle)

    def notifyAddressReleased(self, address):
        self.speedTimer.stop()
        self.throttle = None
        self.speedAction.setThrottle(self.throttle)

    def notifyConsistAddressChosen(self, address, isLong):
        self.notifyAddressChosen(address)

    def notifyConsistAddressThrottleFound(self, throttle):
        self.notifyAddressThrottleFound(throttle)

    def notifyConsistAddressReleased(self, address, isLong):
        self.notifyAddressReleased(address)
Пример #5
0
class WiimoteThrottle2(Jynstrument, PropertyChangeListener, AddressListener,
                       WiiDeviceDiscoveryListener, WiiRemoteListener,
                       Runnable):
    #Jynstrument main and mandatory methods
    def getExpectedContextClassName(self):
        return "jmri.jmrit.throttle.ThrottleWindow"

    def init(self):
        self.getContext().addPropertyChangeListener(
            self)  #ThrottleFrame change
        self.addressPanel = self.getContext().getCurrentThrottleFrame(
        ).getAddressPanel()
        self.addressPanel.addAddressListener(
            self)  # change of throttle in Current frame
        self.throttle = self.getContext().getCurrentThrottleFrame(
        ).getAddressPanel().getThrottle()  # the throttle
        self.speedAction = SpeedAction()  #Speed increase thread
        self.speedAction.setThrottle(self.throttle)
        self.speedTimer = Timer(
            valueSpeedTimerRepeat, self.speedAction
        )  # Very important to use swing Timer object (see Swing and multithreading doc)
        self.speedTimer.setRepeats(True)
        self.label = JButton(
            ImageIcon(self.getFolder() + "/WiimoteThrottle2.png",
                      "WiiMote"))  #label
        self.label.addMouseListener(
            self.getMouseListeners()
            [0])  # In order to get the popupmenu on the button too
        self.add(self.label)
        self.lastTimeButton1 = Calendar.getInstance().getTimeInMillis()
        self.lastTimeButton2 = Calendar.getInstance().getTimeInMillis()
        self.advFunctions = AdvFunctions()
        self.lastTimeEStop = Calendar.getInstance().getTimeInMillis()
        self.wiiDevice = None
        self.sync = thread.allocate_lock()  # A lock protecting bellow self.evt
        self.evt = None
        java.lang.System.setProperty("bluecove.jsr82.psm_minimum_off", "true")
        # Required for Bluecove + WiiRemoteJ
        WiiRemoteJ.findRemotes(self, 1)  # Search for 1 Wiimote, and call back

    def quit(self):
        self.speedTimer.stop()
        WiiRemoteJ.stopFind()
        if ((self.wiiDevice != None) and (self.wiiDevice.isConnected())):
            self.wiiDevice.removeWiiRemoteListener(self)
            self.wiiDevice.disconnect()
        self.wiiDevice = None
        self.speedAction = None
        self.speedTimer = None
        self.throttle = None
        self.advFunctions = None
        self.getContext().removePropertyChangeListener(self)
        self.addressPanel.removeAddressListener(self)
        self.addressPanel = None

    #Wiimote discoverer events

    def findFinished(self, nb):
        print "Search finished, found ", nb, " wiimotes"

    def wiiDeviceDiscovered(self, evt):
        print "Found a Wiimote, number: ", evt.getNumber()
        self.wiiDevice = evt.getWiiDevice()
        ledLights = [False, False, False, False]
        ledLights[evt.getNumber() % 4] = True
        self.wiiDevice.setLEDLights(ledLights)
        self.wiiDevice.addWiiRemoteListener(self)

    #Wiimote events
    def buttonInputReceived(self, evt):
        #        print("Wiimote Button event: ", evt)
        self.sync.acquire()
        self.evt = evt
        self.sync.release()
        SwingUtilities.invokeLater(
            self
        )  # Delegate processing to Swing thread (when we are here, we're in the WiiRemoteJ driver thread)

    def run(self):
        self.sync.acquire()
        evt = self.evt
        self.sync.release()
        if (self.speedTimer != None):
            self.speedTimer.stop()  # In any case
        # ThrottleFrames
        if (evt.wasReleased(WRButtonEvent.RIGHT)):  # NEXT
            self.getContext().nextThrottleFrame()
        if (evt.wasReleased(WRButtonEvent.LEFT)):  # PREVIOUS
            self.getContext().previousThrottleFrame()
        if (evt.wasReleased(WRButtonEvent.UP)):  # NEXT RUNNING
            self.getContext().nextRunningThrottleFrame()
        if (evt.wasReleased(WRButtonEvent.DOWN)):  # PREVIOUS RUNNING
            self.getContext().previousRunningThrottleFrame()
        # No throttle assigned to current frame, browse through roster
        if (self.throttle == None):
            if (evt.wasReleased(
                    WRButtonEvent.HOME)):  # Assign selected roster entry
                self.addressPanel.selectRosterEntry()
                return
            if (evt.wasReleased(WRButtonEvent.PLUS)):  # Next roster entry
                selectedIndex = self.addressPanel.getRosterSelectedIndex()
                self.addressPanel.setIcon(False)
                self.addressPanel.setVisible(True)
                self.addressPanel.setRosterSelectedIndex(selectedIndex + 1)
                return
            if (evt.wasReleased(WRButtonEvent.MINUS)):  # Previous roster entry
                selectedIndex = self.addressPanel.getRosterSelectedIndex()
                self.addressPanel.setIcon(False)
                self.addressPanel.setVisible(True)
                self.addressPanel.setRosterSelectedIndex(selectedIndex - 1)
                return
        # Throttle assigned to current frame, control it
        if (self.throttle != None):
            # Speed control
            if (evt.isPressed(WRButtonEvent.B)):  # SPEED - increment
                self.speedAction.setSpeedIncrement(valueSpeedIncrement)
                self.speedTimer.start()
            if (evt.isPressed(WRButtonEvent.A)):  # SPEED - decrement
                self.speedAction.setSpeedIncrement(-valueSpeedIncrement)
                self.speedTimer.start()
            # EStop
            if (evt.isPressed(WRButtonEvent.PLUS
                              | WRButtonEvent.MINUS)):  # estop = + & -
                self.throttle.setSpeedSetting(speedEStopSpeed)
                self.lastTimeEStop = Calendar.getInstance().getTimeInMillis(
                )  # To cancel next inputs
                self.wiiDevice.vibrateFor(750)
            # Directions
            if (evt.wasReleased(WRButtonEvent.PLUS)):  # FORWARD
                self.throttle.setIsForward(True)
            if (evt.wasReleased(WRButtonEvent.MINUS)):  # BACKWARD
                self.throttle.setIsForward(False)
            # Home : F0
            if (evt.wasReleased(WRButtonEvent.HOME)):  # LIGHTS
                if not ((self.addressPanel.getRosterEntry() != None) and
                        (self.advFunctions.call(
                            self.addressPanel.getRosterEntry(), "0", False,
                            self.throttle) != None)):
                    self.throttle.setF0(not self.throttle.getF0())
            # Wiimote 1 & 2 buttons
            if (evt.isPressed(WRButtonEvent.ONE)):
                if not ((self.addressPanel.getRosterEntry() != None) and
                        (self.advFunctions.call(
                            self.addressPanel.getRosterEntry(), "1", True,
                            self.throttle) != None)):
                    pass  # default F1 not momentary (switch only on Release, do nothing here)
            if (evt.wasReleased(WRButtonEvent.ONE)):
                if not ((self.addressPanel.getRosterEntry() != None) and
                        (self.advFunctions.call(
                            self.addressPanel.getRosterEntry(), "1", False,
                            self.throttle) != None)):
                    self.throttle.setF1(
                        not self.throttle.getF1())  # default F1 not momentary
            if (evt.isPressed(WRButtonEvent.TWO)):
                if not ((self.addressPanel.getRosterEntry() != None) and
                        (self.advFunctions.call(
                            self.addressPanel.getRosterEntry(), "2", True,
                            self.throttle) != None)):
                    self.throttle.setF2(True)  # default F2 momentary
            if (evt.wasReleased(WRButtonEvent.TWO)):
                if not ((self.addressPanel.getRosterEntry() != None) and
                        (self.advFunctions.call(
                            self.addressPanel.getRosterEntry(), "2", False,
                            self.throttle) != None)):
                    self.throttle.setF2(False)

    def disconnected(self):
        self.wiiDevice = None
        print("Lost wiimote")

    def accelerationInputReceived(self, evt):
        pass

    def combinedInputReceived(self, evt):
        pass

    def extensionConnected(self, extension):
        pass

    def extensionDisconnected(self, extension):
        pass

    def extensionInputReceived(self, evt):
        pass

    def extensionPartiallyInserted(self):
        pass

    def extensionUnknown(self):
        pass

    def IRInputReceived(self, evt):
        pass

    def statusReported(self, evt):
        print("Wiimote status reported: ", evt)

#Property listener part

    def propertyChange(self, event):
        self.speedTimer.stop()
        if (event.propertyName == "ThrottleFrame"
            ):  # Current throttle frame changed
            event.oldValue.getAddressPanel().removeAddressListener(self)
            self.addressPanel = event.newValue.getAddressPanel()
            self.throttle = self.addressPanel.getThrottle()
            self.speedAction.setThrottle(self.throttle)
            self.addressPanel.addAddressListener(self)

#AddressListener part: to listen for address changes in address panel (release, acquired)

    def notifyAddressChosen(self, address):
        pass

    def notifyAddressThrottleFound(self, throttle):
        self.speedTimer.stop()
        self.throttle = throttle
        self.speedAction.setThrottle(self.throttle)

    def notifyAddressReleased(self, address):
        self.speedTimer.stop()
        self.throttle = None
        self.speedAction.setThrottle(self.throttle)

    def notifyConsistAddressChosen(self, address, isLong):
        self.notifyAddressChosen(address)

    def notifyConsistAddressThrottleFound(self, throttle):
        self.notifyAddressThrottleFound(throttle)

    def notifyConsistAddressReleased(self, address, isLong):
        self.notifyAddressReleased(address)
Пример #6
0
class USBThrottle(Jynstrument, PropertyChangeListener, AddressListener):
#Property listener part: USB value
    def propertyChange(self, event):
        # Customize bellow for throttles calls:
        if (event.propertyName == "Value") :  # USB
            if (event.oldValue.getController() == self.desiredController ) :
                component = event.oldValue.getComponent().toString()
                value = event.newValue
                # Uncomment bellow line to see component name and its value
                # print "Component",component,"value changed to",value
                try:
                    # Change current ThrottleFrame
                    if ((component == self.driver.componentNextThrottleFrame) and (value == self.driver.valueNextThrottleFrame)) : #NEXT
                        self.getContext().nextThrottleFrame()
                    if  ((component == self.driver.componentPreviousThrottleFrame) and (value == self.driver.valuePreviousThrottleFrame)) : #PREVIOUS
                        self.getContext().previousThrottleFrame()
                    if ((component == self.driver.componentNextRunningThrottleFrame) and (value == self.driver.valueNextRunningThrottleFrame)) : #NEXT RUNNING
                        self.getContext().nextRunningThrottleFrame()
                    if  ((component == self.driver.componentPreviousRunningThrottleFrame) and (value == self.driver.valuePreviousRunningThrottleFrame)) : #PREVIOUS RUNNING
                        self.getContext().previousRunningThrottleFrame()  
                except AttributeError:
                    pass
                
                if (self.throttle == None) :
                    try:
                        # Browse through roster
                        if ((component == self.driver.componentNextRosterBrowse) and (value == self.driver.valueNextRoster)): #NEXT
                            selectedIndex = self.addressPanel.getRosterSelectedIndex()
                            self.addressPanel.setVisible(True)
                            self.addressPanel.setIcon(False)
                            self.addressPanel.setRosterSelectedIndex(selectedIndex + 1)
                        if ((component == self.driver.componentPreviousRosterBrowse) and (value == self.driver.valuePreviousRoster)) : #PREVIOUS
                            selectedIndex = self.addressPanel.getRosterSelectedIndex()
                            self.addressPanel.setVisible(True)
                            self.addressPanel.setIcon(False)                            
                            self.addressPanel.setRosterSelectedIndex(selectedIndex - 1)
                    except AttributeError:
                        pass
                    try:
                        # Request a throttle
                        if ((component == self.driver.componentRosterSelect) and (value == self.driver.valueRosterSelect)):
                            self.addressPanel.selectRosterEntry()
                    except AttributeError:
                        pass
                        
                # From there; current throttle control, hence require a throttle
                if (self.throttle != None) :
                    # Release current throttle
                    try:
                        if ((component == self.driver.componentThrottleRelease) and (value == self.driver.valueThrottleRelease)):
                            self.addressPanel.dispatchAddress()
                    except AttributeError:
                        pass
                    
                    try:
                        # Speed - dynamic controler (joystick going back to neutral position)
                        if ((component == self.driver.componentSpeedIncrease) or (component == self.driver.componentSpeedDecrease) or (component == self.driver.componentSpeed)):
                            if ((component == self.driver.componentSpeedIncrease) and (value == self.driver.valueSpeedIncrease)) :
                                self.speedAction.setSpeedIncrement( 0.03 )
                            if ((component == self.driver.componentSpeedDecrease) and (value == self.driver.valueSpeedDecrease)) :
                                self.speedAction.setSpeedIncrement( -0.03 )
                            if (component == self.driver.componentSpeed) :
                                try:
                                    self.vsd = valueSpeedDivider * self.driver.componentSpeedMultiplier
                                except AttributeError:
                                    self.vsd = valueSpeedDivider
                                self.speedAction.setSpeedIncrement(value / self.vsd)
                            if ( abs(value) > self.driver.valueSpeedTrigger ) :
                                self.speedTimer.start()
                            else :
                                self.speedTimer.stop()
                    except AttributeError:
                        self.speedTimer.stop() # just in case, stop it, really should never get there
                    
                    try:
                        # Speed v2 - static controler (lever on RailDriver or AAR105)
                        if (component == self.driver.componentSpeedSet):
                            # negative is lever front, positive is lever back
                            # limit range to only positive side of lever
                            if (value < self.driver.valueSpeedSetMinValue) : value = self.driver.valueSpeedSetMinValue
                            if (value > self.driver.valueSpeedSetMaxValue) : value = self.driver.valueSpeedSetMaxValue
                            # convert fraction of input to speed step
                            self.throttle.setSpeedSetting((value-self.driver.valueSpeedSetMinValue)/(self.driver.valueSpeedSetMaxValue-self.driver.valueSpeedSetMinValue))
                            print "Slider Speed:", self.controlPanel.getDisplaySlider()
                    except AttributeError:
                        pass
                    # Direction
                    try:
                        if ((component == self.driver.componentDirectionForward) and (value == self.driver.valueDirectionForward)) :
                            self.throttle.setIsForward(True)
                        if ((component == self.driver.componentDirectionBackward) and (value == self.driver.valueDirectionBackward)) :
                            self.throttle.setIsForward(False)
                    except AttributeError:
                        pass                    
                    try:                    
                        if ((component == self.driver.componentDirectionSwitch) and (value == self.driver.valueDirectionSwitch)) :
                            self.throttle.setIsForward(not self.throttle.getIsForward())
                    except AttributeError:
                        pass
                    
                    # Speed presets
                    try:  # STOP
                        if ((component == self.driver.componentStopSpeed) and (value == self.driver.valueStopSpeed)) :
                            if ( Calendar.getInstance().getTimeInMillis() - self.lastTimeStopButton < delay4doubleTap ) : 
                                self.throttle.setSpeedSetting(EStopSpeed) # EStop on double tap
                            else:
                                self.throttle.setSpeedSetting(speedStopSpeed)
                            self.lastTimeStopButton = Calendar.getInstance().getTimeInMillis()
                    except AttributeError:
                        pass
                    try:   # EStop
                        if ((component == self.driver.componentEStopSpeed) and (value == self.driver.valueEStopSpeed)):
                            self.throttle.setSpeedSetting(EStopSpeed)
                    except AttributeError:
                        pass
                    try:   # EStop
                        if ((component == self.driver.componentEStopSpeedBis) and (value == self.driver.valueEStopSpeedBis)):
                            self.throttle.setSpeedSetting(EStopSpeed)
                    except AttributeError:
                        pass
                    try:   # SLOW
                        if ((component == self.driver.componentSlowSpeed) and (value == self.driver.valueSlowSpeed)) :
                            self.throttle.setSpeedSetting(speedSlowSpeed)
                    except AttributeError:
                        pass
                    try:   # CRUISE
                        if ((component == self.driver.componentCruiseSpeed) and (value == self.driver.valueCruiseSpeed)) :
                            if ( Calendar.getInstance().getTimeInMillis() - self.lastTimeCruiseButton < delay4doubleTap ) : # EStop on double tap
                                self.throttle.setSpeedSetting(speedMaxSpeed) # Max speed on double tap
                            else:
                                self.throttle.setSpeedSetting(speedCruiseSpeed)
                            self.lastTimeCruiseButton = Calendar.getInstance().getTimeInMillis()
                    except AttributeError:
                        pass
                    try:   # MAX
                        if ((component == self.driver.componentMaxSpeed) and (value == self.driver.valueMaxSpeed)) :
                            self.throttle.setSpeedSetting(speedMaxSpeed)
                    except AttributeError:
                        pass
                        
                    # Functions
                    try:
                        if ((component == self.driver.componentF0) and (value == self.driver.valueF0)) :
                            self.throttle.setF0( not self.throttle.getF0() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(0)) and (component == self.driver.componentF0) and (value == self.driver.valueF0Off)) :
                            self.throttle.setF0( not self.throttle.getF0() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF1) and (value == self.driver.valueF1)) :
                            self.throttle.setF1( not self.throttle.getF1() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(1)) and (component == self.driver.componentF1) and (value == self.driver.valueF1Off)) :
                            self.throttle.setF1( not self.throttle.getF1() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF2) and (value == self.driver.valueF2)) :
                            self.throttle.setF2( not self.throttle.getF2() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(2)) and (component == self.driver.componentF2) and (value == self.driver.valueF2Off)) :
                            self.throttle.setF2( not self.throttle.getF2() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF3) and (value == self.driver.valueF3)) :
                            self.throttle.setF3( not self.throttle.getF3() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(3)) and (component == self.driver.componentF3) and (value == self.driver.valueF3Off)) :
                            self.throttle.setF3( not self.throttle.getF3() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF4) and (value == self.driver.valueF4)) :
                            self.throttle.setF4( not self.throttle.getF4() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(4)) and (component == self.driver.componentF4) and (value == self.driver.valueF4Off)) :
                            self.throttle.setF4( not self.throttle.getF4() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF5) and (value == self.driver.valueF5)) :
                            self.throttle.setF5( not self.throttle.getF5() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(5)) and (component == self.driver.componentF5) and (value == self.driver.valueF5Off)) :
                            self.throttle.setF5( not self.throttle.getF5() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF6) and (value == self.driver.valueF6)) :
                            self.throttle.setF6( not self.throttle.getF6() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(6)) and (component == self.driver.componentF6) and (value == self.driver.valueF6Off)) :
                            self.throttle.setF6( not self.throttle.getF6() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF7) and (value == self.driver.valueF7)) :
                            self.throttle.setF7( not self.throttle.getF7() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(7)) and (component == self.driver.componentF7) and (value == self.driver.valueF7Off)) :
                            self.throttle.setF7( not self.throttle.getF7() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF8) and (value == self.driver.valueF8)) :
                            self.throttle.setF8( not self.throttle.getF8() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(8)) and (component == self.driver.componentF8) and (value == self.driver.valueF8Off)) :
                            self.throttle.setF8( not self.throttle.getF8() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF9) and (value == self.driver.valueF9)) :
                            self.throttle.setF9( not self.throttle.getF9() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(9)) and (component == self.driver.componentF9) and (value == self.driver.valueF9Off)) :
                            self.throttle.setF9( not self.throttle.getF9() )
                    except AttributeError:
                        pass  
                    try:
                        if ((component == self.driver.componentF10) and (value == self.driver.valueF10)) :
                            self.throttle.setF10( not self.throttle.getF10() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(10)) and (component == self.driver.componentF10) and (value == self.driver.valueF10Off)) :
                            self.throttle.setF10( not self.throttle.getF10() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF11) and (value == self.driver.valueF11)) :
                            self.throttle.setF11( not self.throttle.getF11() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(11)) and (component == self.driver.componentF11) and (value == self.driver.valueF11Off)) :
                            self.throttle.setF11( not self.throttle.getF11() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF12) and (value == self.driver.valueF12)) :
                            self.throttle.setF12( not self.throttle.getF12() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(12)) and (component == self.driver.componentF12) and (value == self.driver.valueF12Off)) :
                            self.throttle.setF12( not self.throttle.getF12() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF13) and (value == self.driver.valueF13)) :
                            self.throttle.setF13( not self.throttle.getF13() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(13)) and (component == self.driver.componentF13) and (value == self.driver.valueF13Off)) :
                            self.throttle.setF13( not self.throttle.getF13() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF14) and (value == self.driver.valueF14)) :
                            self.throttle.setF14( not self.throttle.getF14() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(14)) and (component == self.driver.componentF14) and (value == self.driver.valueF14Off)) :
                            self.throttle.setF14( not self.throttle.getF14() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF15) and (value == self.driver.valueF15)) :
                            self.throttle.setF15( not self.throttle.getF15() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(15)) and (component == self.driver.componentF15) and (value == self.driver.valueF15Off)) :
                            self.throttle.setF15( not self.throttle.getF15() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF16) and (value == self.driver.valueF16)) :
                            self.throttle.setF16( not self.throttle.getF16() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(16)) and (component == self.driver.componentF16) and (value == self.driver.valueF16Off)) :
                            self.throttle.setF16( not self.throttle.getF16() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF17) and (value == self.driver.valueF17)) :
                            self.throttle.setF17( not self.throttle.getF17() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(17)) and (component == self.driver.componentF17) and (value == self.driver.valueF17Off)) :
                            self.throttle.setF17( not self.throttle.getF17() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF18) and (value == self.driver.valueF18)) :
                            self.throttle.setF18( not self.throttle.getF18() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(18)) and (component == self.driver.componentF18) and (value == self.driver.valueF18Off)) :
                            self.throttle.setF18( not self.throttle.getF18() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF19) and (value == self.driver.valueF19)) :
                            self.throttle.setF19( not self.throttle.getF19() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(19)) and (component == self.driver.componentF19) and (value == self.driver.valueF19Off)) :
                            self.throttle.setF19( not self.throttle.getF19() )
                    except AttributeError:
                        pass   
                    
                    try:
                        if ((component == self.driver.componentF20) and (value == self.driver.valueF20)) :
                            self.throttle.setF20( not self.throttle.getF20() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(20)) and (component == self.driver.componentF20) and (value == self.driver.valueF20Off)) :
                            self.throttle.setF20( not self.throttle.getF20() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF21) and (value == self.driver.valueF21)) :
                            self.throttle.setF21( not self.throttle.getF21() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(21)) and (component == self.driver.componentF21) and (value == self.driver.valueF21Off)) :
                            self.throttle.setF21( not self.throttle.getF21() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF22) and (value == self.driver.valueF22)) :
                            self.throttle.setF22( not self.throttle.getF22() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(22)) and (component == self.driver.componentF22) and (value == self.driver.valueF22Off)) :
                            self.throttle.setF22( not self.throttle.getF22() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF23) and (value == self.driver.valueF23)) :
                            self.throttle.setF23( not self.throttle.getF23() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(23)) and (component == self.driver.componentF23) and (value == self.driver.valueF23Off)) :
                            self.throttle.setF23( not self.throttle.getF23() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF24) and (value == self.driver.valueF24)) :
                            self.throttle.setF24( not self.throttle.getF24() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(24)) and (component == self.driver.componentF24) and (value == self.driver.valueF24Off)) :
                            self.throttle.setF24( not self.throttle.getF24() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF25) and (value == self.driver.valueF25)) :
                            self.throttle.setF25( not self.throttle.getF25() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(25)) and (component == self.driver.componentF25) and (value == self.driver.valueF25Off)) :
                            self.throttle.setF25( not self.throttle.getF25() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF26) and (value == self.driver.valueF26)) :
                            self.throttle.setF26( not self.throttle.getF26() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(26)) and (component == self.driver.componentF26) and (value == self.driver.valueF26Off)) :
                            self.throttle.setF26( not self.throttle.getF26() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF27) and (value == self.driver.valueF27)) :
                            self.throttle.setF27( not self.throttle.getF27() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(27)) and (component == self.driver.componentF27) and (value == self.driver.valueF27Off)) :
                            self.throttle.setF27( not self.throttle.getF27() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF28) and (value == self.driver.valueF28)) :
                            self.throttle.setF28( not self.throttle.getF28() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(28)) and (component == self.driver.componentF28) and (value == self.driver.valueF28Off)) :
                            self.throttle.setF28( not self.throttle.getF28() )
                    except AttributeError:
                        pass
                    try:
                        if ((component == self.driver.componentF29) and (value == self.driver.valueF29)) :
                            self.throttle.setF29( not self.throttle.getF29() )
                        if ((self.roster != None) and (not self.roster.getFunctionLockable(29)) and (component == self.driver.componentF29) and (value == self.driver.valueF29Off)) :
                            self.throttle.setF29( not self.throttle.getF29() )
                    except AttributeError:
                        pass
                        
        # Nothing to customize bellow this point
        if (event.propertyName == "ThrottleFrame") :  # Current throttle frame changed
            self.speedTimer.stop()
            event.oldValue.getAddressPanel().removeAddressListener(self)
            self.addressPanel = event.newValue.getAddressPanel()
            self.throttle = self.addressPanel.getThrottle()
            self.roster = self.addressPanel.getRosterEntry()
            self.speedAction.setThrottle( self.throttle )
            event.newValue.getAddressPanel().addAddressListener(self)

#Jynstrument main and mandatory methods
    def getExpectedContextClassName(self):
        return "jmri.jmrit.throttle.ThrottleWindow"
    
    def init(self):
        self.getContext().addPropertyChangeListener(self) #ThrottleFrame change
        self.getContext().getCurrentThrottleFrame().getAddressPanel().addAddressListener(self) # change of throttle in Current frame
        self.addressPanel = self.getContext().getCurrentThrottleFrame().getAddressPanel()
        self.throttle = self.addressPanel.getThrottle() # the throttle
        self.roster = self.addressPanel.getRosterEntry() # roster entry if any
        self.speedAction =  SpeedAction()  #Speed increase thread
        self.speedAction.setThrottle( self.throttle )
        self.speedTimer = Timer(valueSpeedTimerRepeat, self.speedAction ) # Very important to use swing Timer object (see Swing and multithreading doc)
        self.speedTimer.setRepeats(True)
        self.label = JButton(ImageIcon(self.getFolder() + "/USBControl.png","USBThrottle")) #label
        self.label.addMouseListener(self.getMouseListeners()[0]) # In order to get the popupmenu on the button too
        self.add(self.label)
        self.model = jmri.jmrix.jinput.TreeModel.instance() # USB
        self.desiredController = None
        self.ctrlMenuItem = []
        self.USBDriver = None
        self.driver = None
        mi = JCheckBoxMenuItem ("None")
        self.getPopUpMenu().add( mi )
        mi.addItemListener( ControllerItemListener(None, self) )
        self.ctrlMenuItem.append(mi)
        for ctrl in self.model.controllers(): 
            mi = JCheckBoxMenuItem (ctrl.getName())
            self.getPopUpMenu().add( mi )
            mi.addItemListener( ControllerItemListener(ctrl, self) )
            self.ctrlMenuItem.append(mi)
        if ( len(self.ctrlMenuItem) == 0 ):
            print "No matching USB device found"
        else:
            self.ctrlMenuItem[0].setSelected(True)  # by default connect to the first one
        self.model.addPropertyChangeListener(self)
        self.lastTimeStopButton = Calendar.getInstance().getTimeInMillis()
        self.lastTimeCruiseButton = Calendar.getInstance().getTimeInMillis()

# On quit clean up resources       
    def quit(self):
        self.speedTimer.stop()
        for mi in self.ctrlMenuItem :
            self.getPopUpMenu().remove( mi )
        self.ctrlMenuItem = None
        self.speedAction = None
        self.speedTimer = None
        self.throttle = None
        self.addressPanel = None
        self.driver = None
        self.USBDriver = None
        self.getContext().removePropertyChangeListener(self)
        self.model.removePropertyChangeListener(self)
        self.getContext().getCurrentThrottleFrame().getAddressPanel().removeAddressListener(self)

# Menu entry changed for Current controller and update driver
    def setSelectedController(self, ctrl, item):
        for mi in self.ctrlMenuItem :
            if ( mi != item ):  # Force deselection of other ones
                mi.setSelected(False)
        self.desiredController = ctrl
        if (ctrl != None) :
            sys.path.append(self.getFolder()) # Load a driver
            try:
                del self.driver
                del self.USBDriver
                dd=ctrl.getName()
                dd=dd.replace(" ", "")
                dd=dd.replace(".", "")
                dd=dd.replace("(", "")
                dd=dd.replace(")", "")
                dd=dd.replace("{", "")
                dd=dd.replace("}", "")
                dd=dd.replace("[", "")
                dd=dd.replace("]", "")              
                self.USBDriver = __import__(dd)           
            except ImportError:  # On error load a default one
                print "Driver \""+ dd +"\" not found in \""+self.getFolder()+"\", loading default one"
                self.USBDriver =  __import__("Default")
            reload(self.USBDriver)
            sys.path.remove(self.getFolder())
            self.driver = self.USBDriver.USBDriver()
    
    def setXml(self, elt):
        if (elt.getChildren("USBThrottle") == None):
            return
        ctrl = elt.getChildren("USBThrottle")[0].getAttributeValue("DesiredController")
        if (ctrl == None):
            return
        for mi in self.ctrlMenuItem :
            if ( mi.getText() == ctrl ):
                mi.setSelected(True)
                break
    
    def getXml(self):
       elt = Element("USBThrottle")
       for mi in self.ctrlMenuItem :
           if (mi.isSelected()) :
               elt.setAttribute("DesiredController", mi.getText())
               break
       return elt

#AddressListener part: to listen for address changes in address panel (release, acquired)
    def notifyAddressChosen(self, address):
        pass
        
    def notifyAddressThrottleFound(self, throttle):
        self.speedTimer.stop() 
        self.throttle = throttle
        self.speedAction.setThrottle( self.throttle )
            
    def notifyAddressReleased(self, address):
        self.speedTimer.stop()
        self.throttle = None
        self.speedAction.setThrottle( self.throttle )

    def notifyConsistAddressChosen(self, address, isLong):
        self.notifyAddressChosen(address)

    def notifyConsistAddressThrottleFound(self, throttle):
        self.notifyAddressThrottleFound(throttle)

    def notifyConsistAddressReleased(self, address, isLong):
        self.notifyAddressReleased(address)
Пример #7
0
class WiimoteThrottle(Jynstrument, PropertyChangeListener, AddressListener, WiiDeviceDiscoveryListener, WiiRemoteListener, Runnable):
    #Wiimote discoverer events
    def findFinished(self, nb):
        print "Search finished, found ",nb ," wiimotes"

    def wiiDeviceDiscovered(self, evt):
        print "Found a Wiimote, number: ", evt.getNumber()
        self.wiiDevice = evt.getWiiDevice()
        ledLights = [False, False, False, False]
        ledLights[evt.getNumber()%4] = True
        self.wiiDevice.setLEDLights(ledLights)
        self.wiiDevice.addWiiRemoteListener(self)

    #Wiimote events        
    def buttonInputReceived(self, evt):
#        print("Wiimote Button event: ", evt)
        self.sync.acquire()
        self.evt = evt
        self.sync.release()
        SwingUtilities.invokeLater(self) # Delegate processing to Swing thread (when we are here, we're in the WiiRemoteJ driver thread)

    def run(self):
        self.sync.acquire()
        evt = self.evt
        self.sync.release()
        if (self.speedTimer != None):
            self.speedTimer.stop() # In any case
        # ThrottleFrames
        if ( evt.wasReleased(WRButtonEvent.RIGHT) ): # NEXT
             self.getContext().nextThrottleFrame()
        if ( evt.wasReleased(WRButtonEvent.LEFT) ):  # PREVIOUS
            self.getContext().previousThrottleFrame()
        if ( evt.wasReleased(WRButtonEvent.UP) ): # NEXT RUNNING
             self.getContext().nextRunningThrottleFrame()
        if ( evt.wasReleased(WRButtonEvent.DOWN) ):  # PREVIOUS RUNNING
            self.getContext().previousRunningThrottleFrame()  
        # No throttle assigned to current frame, browse through roster      
        if (self.throttle == None):
            if ( evt.wasReleased(WRButtonEvent.HOME) ):  # Assign selected roster entry
                self.addressPanel.selectRosterEntry()
                return
            if ( evt.wasReleased(WRButtonEvent.PLUS) ):  # Next roster entry
                selectedIndex = self.addressPanel.getRosterSelectedIndex()
                self.addressPanel.setIcon(False)
                self.addressPanel.setVisible(True)
                self.addressPanel.setRosterSelectedIndex(selectedIndex + 1)
                return
            if ( evt.wasReleased(WRButtonEvent.MINUS) ):  # Previous roster entry
                selectedIndex = self.addressPanel.getRosterSelectedIndex()
                self.addressPanel.setIcon(False)
                self.addressPanel.setVisible(True)
                self.addressPanel.setRosterSelectedIndex(selectedIndex - 1)
                return
        # Throttle assigned to current frame, control it  
        if (self.throttle != None):
            if ( evt.wasReleased(WRButtonEvent.HOME) ):  # LIGHTS
                self.throttle.setF0( not self.throttle.getF0() )
                return
            if ( evt.wasReleased(WRButtonEvent.PLUS) ):  # FORWARD
                self.throttle.setIsForward(True)
                return
            if ( evt.wasReleased(WRButtonEvent.MINUS) ):  # BACKWARD
                self.throttle.setIsForward(False)
                return
            # Speed control
            if ( evt.isPressed(WRButtonEvent.B) ): # SPEED - increment
                self.speedAction.setSpeedIncrement( valueSpeedIncrement )
                self.speedTimer.start()
                return
            if ( evt.isPressed(WRButtonEvent.A) ): # SPEED - decrement
                self.speedAction.setSpeedIncrement( -valueSpeedIncrement )
                self.speedTimer.start()
                return
            # EStop
            if ( evt.isPressed( WRButtonEvent.ONE | WRButtonEvent.TWO ) ): # estop = button1 + button2
                self.throttle.setSpeedSetting( speedEStopSpeed )
                self.lastTimeEStop = Calendar.getInstance().getTimeInMillis() # To cancel next inputs
                self.wiiDevice.vibrateFor(750)
                return
            # Speed presets
            if (Calendar.getInstance().getTimeInMillis() - self.lastTimeEStop > delay4double): # Delay for nothing after EStop
                if (( evt.wasReleased(WRButtonEvent.TWO) ) and           #STOP = button2 x2 or (button2 and CurrentSpeed = slow speed)
                    ( (Calendar.getInstance().getTimeInMillis() - self.lastTimeButton2 < delay4double) or ( self.throttle.getSpeedSetting() == speedSlowSpeed ))):  
                    self.throttle.setSpeedSetting( speedStopSpeed )
                    return
                if ( evt.wasReleased(WRButtonEvent.TWO) ):               # SLOW SPEED = button2
                    self.throttle.setSpeedSetting( speedSlowSpeed )
                    self.lastTimeButton2 = Calendar.getInstance().getTimeInMillis()
                    return
                if (( evt.wasReleased(WRButtonEvent.ONE) ) and           # MAX SPEED = button1x2 or (button1 and CurrentSpeed = cruise speed)
                    ( (Calendar.getInstance().getTimeInMillis() - self.lastTimeButton1 < delay4double) or ( self.throttle.getSpeedSetting() == speedCruiseSpeed ))): 
                    self.throttle.setSpeedSetting( speedMaxSpeed )
                    return
                if ( evt.wasReleased( WRButtonEvent.ONE) ):              # CRUISE SPEED = button1
                    self.throttle.setSpeedSetting( speedCruiseSpeed )
                    self.lastTimeButton1 = Calendar.getInstance().getTimeInMillis()
                    return

    def disconnected(self):
        self.wiiDevice = None
        print("Lost wiimote")
        
    def accelerationInputReceived(self, evt):
        pass
    def combinedInputReceived(self, evt):
        pass
    def	extensionConnected(self, extension):
        pass          
    def	extensionDisconnected(self, extension):
        pass          
    def extensionInputReceived(self, evt):
        pass
    def	extensionPartiallyInserted(self):
        pass
    def extensionUnknown(self):
        pass
    def IRInputReceived(self, evt):
        pass
    def statusReported(self, evt):
        print("Wiimote status reported: ", evt)

#Property listener part
    def propertyChange(self, event):
        self.speedTimer.stop()                     
        if (event.propertyName == "ThrottleFrame") :  # Current throttle frame changed
            event.oldValue.getAddressPanel().removeAddressListener(self)
            self.addressPanel = event.newValue.getAddressPanel()
            self.throttle = self.addressPanel.getThrottle()
            self.speedAction.setThrottle( self.throttle )
            self.addressPanel.addAddressListener(self)

#Jynstrument main and mandatory methods
    def getExpectedContextClassName(self):
        return "jmri.jmrit.throttle.ThrottleWindow"
    
    def init(self):
        self.getContext().addPropertyChangeListener(self) #ThrottleFrame change
        self.addressPanel=self.getContext().getCurrentThrottleFrame().getAddressPanel();
        self.addressPanel.addAddressListener(self) # change of throttle in Current frame
        self.throttle = self.getContext().getCurrentThrottleFrame().getAddressPanel().getThrottle() # the throttle
        self.speedAction =  SpeedAction()  #Speed increase thread
        self.speedAction.setThrottle( self.throttle )
        self.speedTimer = Timer(valueSpeedTimerRepeat, self.speedAction ) # Very important to use swing Timer object (see Swing and multithreading doc)
        self.speedTimer.setRepeats(True)
        self.label = JButton(ImageIcon(self.getFolder() + "/WiimoteThrottle.png","WiiMote")) #label
        self.label.addMouseListener(self.getMouseListeners()[0]) # In order to get the popupmenu on the button too
        self.add(self.label)
        self.lastTimeButton1 = Calendar.getInstance().getTimeInMillis()
        self.lastTimeButton2 = Calendar.getInstance().getTimeInMillis()
        self.lastTimeEStop = Calendar.getInstance().getTimeInMillis()
        self.wiiDevice = None
        self.sync = thread.allocate_lock() # A lock protecting bellow self.evt
        self.evt = None
        java.lang.System.setProperty("bluecove.jsr82.psm_minimum_off", "true"); # Required for Bluecove + WiiRemoteJ
        WiiRemoteJ.findRemotes(self, 1) # Search for 1 Wiimote, and call back
       
    def quit(self):
        self.speedTimer.stop() 
        WiiRemoteJ.stopFind()
        if ((self.wiiDevice != None) and (self.wiiDevice.isConnected())):
            self.wiiDevice.removeWiiRemoteListener(self)
            self.wiiDevice.disconnect()
        self.wiiDevice = None
        self.speedAction = None
        self.speedTimer = None
        self.throttle = None
        self.getContext().removePropertyChangeListener(self)
        self.addressPanel.removeAddressListener(self)
        self.addressPanel = None

#AddressListener part: to listen for address changes in address panel (release, acquired)
    def notifyAddressChosen(self, address):
        pass
        
    def notifyAddressThrottleFound(self, throttle):
        self.speedTimer.stop() 
        self.throttle = throttle
        self.speedAction.setThrottle( self.throttle )
            
    def notifyAddressReleased(self, address):
        self.speedTimer.stop()
        self.throttle = None
        self.speedAction.setThrottle( self.throttle )

    def notifyConsistAddressChosen(self, address, isLong):
        self.notifyAddressChosen(address)

    def notifyConsistAddressThrottleFound(self, throttle):
        self.notifyAddressThrottleFound(throttle)

    def notifyConsistAddressReleased(self, address, isLong):
        self.notifyAddressReleased(address)
Пример #8
0
class FunctionControl(core.DataViewComponent, ComponentListener):
    def __init__(self, view, name, func, label=None):
        core.DataViewComponent.__init__(self, label)
        self.view = view
        self.name = name
        self.func = func
        self.label_height = 18
        self.resize_border = 2

        self.popup_hide_limit = JCheckBoxMenuItem('auto-hide limits', True, actionPerformed=self.toggle_autohide)
        self.popup.add(self.popup_hide_limit)
        self.show_limits = False
        self.auto_hide_limits = True
        self.limits_font = Font("Dialog", Font.PLAIN, 10)
        self.limit_width = 0
        self.limit_hide_delay = 1000
        self.limit_color_def = 0.3
        self.limit_color_val = self.limit_color_def
        self.limit_color_step = (1 - self.limit_color_def) / 10
        self.limit_hide_timer = Timer(self.limit_hide_delay / 10, None, actionPerformed=self.hide_limits)
        self.limit_hide_timer.setRepeats(False)

        self.popup.add(JPopupMenu.Separator())
        self.popup.add(JMenuItem('zero', actionPerformed=self.zero))
        self.popup.add(JMenuItem('set value', actionPerformed=self.set_value))

        self.filename = None
        self.popup.add(JMenuItem('set from file...', actionPerformed=self.set_from_file))

        self.popup.add(JPopupMenu.Separator())
        self.popup.add(JMenuItem('increase range', actionPerformed=self.increase_range))
        self.popup.add(JMenuItem('decrease range', actionPerformed=self.decrease_range))
        self.scale_factor = 0.01
        self.range = 1.0

        self.data = self.view.watcher.watch(name, func)

        values = self.data.get_first()
        self.sliders = []
        self.labels = []
        for i, v in enumerate(values):
            vv = int(v * 100 / self.range)
            if vv > 100:
                vv = 100
            if vv < -100:
                vv = -100
            slider = JSlider(JSlider.VERTICAL, -100, 100, vv, stateChanged=lambda event, index=i: self.slider_moved(index))
            slider.background = Color.white
            self.add(slider)
            self.sliders.append(slider)
            label = JLabel('0.00')
            self.add(label)
            self.labels.append(label)
            slider.addMouseListener(self)

        self.setSize(len(values) * 40 + 40, 200)
        self.addComponentListener(self)
        self.componentResized(None)

    def increase_range(self, event):
        self.range *= 2.0
        self.check_label_size()
        self.repaint()

    def decrease_range(self, event):
        self.range *= 0.5
        self.check_label_size()
        self.repaint()

    def check_label_size(self):
        if(self.show_limits):
            limit_label = JLabel(("-%1.2f" % (self.range)))
            limit_width = limit_label.getPreferredSize().width - self.sliders[0].width / 2

            if(limit_width != self.limit_width):
                self.setSize(self.size.width + limit_width - self.limit_width, self.size.height)
                self.setLocation(self.x - limit_width + self.limit_width, self.y)
                self.limit_width = limit_width

    def zero(self, event):
        for i in range(len(self.sliders)):
            self.set_slider_value(i, 0)

    def set_value(self, event):
        try:
            example = ','.join(['%1.1f' % random.uniform(-5, 5) for i in range(len(self.sliders))])
            text = JOptionPane.showInputDialog(self.view.frame, 'Enter input value. \nExample: %s' % example, "Set value", JOptionPane.PLAIN_MESSAGE, None, None, None)
            v = eval(text)
            if isinstance(v, (int, float)):
                v = [v]
            if len(v) > len(self.sliders):
                v = v[:len(self.sliders)]
            for i, vv in enumerate(v):
                self.set_slider_value(i, vv)
        except:
            self.release_value(event)

    def set_from_file(self, event):
        fileChooser = JFileChooser()
        if self.filename is not None:
            fileChooser.setSelectedFile(java.io.File(self.filename))

        if fileChooser.showOpenDialog(self) == JFileChooser.APPROVE_OPTION:
            self.filename = fileChooser.selectedFile.absolutePath

            #TODO: this doesn't for for nested FunctionInputs
            input = self.view.network.getNode(self.name)

            from nef.functions import Interpolator
            interp = Interpolator(self.filename)
            interp.load_into_function(input)

    def set_slider_value(self, index, value):
        sv = value / (self.scale_factor * self.range)
        self.sliders[index].value = int(sv)
        self.labels[index].text = '%1.2f' % value
        self.check_label_size()
        self.repaint()
        if self.view.paused:  # change immediately, bypassing filter
            self.data.data[-1][index] = value
            self.view.forced_origins_prev[(self.name, 'origin', index)] = value
        self.view.forced_origins[(self.name, 'origin', index)] = value

    def slider_moved(self, index):
        if self.sliders[index].valueIsAdjusting:   # if I moved it
            v = self.sliders[index].value * self.scale_factor * self.range
            self.labels[index].text = '%1.2f' % v
            if self.view.paused:  # change immediately, bypassing filter
                self.data.data[-1][index] = v
                self.view.forced_origins_prev[(self.name, 'origin', index)] = v

            self.view.forced_origins[(self.name, 'origin', index)] = v

    def paintComponent(self, g):
        temp = self.show_label
        self.show_label = False
        core.DataViewComponent.paintComponent(self, g)
        self.show_label = temp

        if self.show_label:
            g.color = Color(0.3, 0.3, 0.3)
            bounds = g.font.getStringBounds(self.label, g.fontRenderContext)
            g.drawString(self.label, (self.size.width - self.limit_width) / 2 - bounds.width / 2 + self.limit_width, bounds.height)

        self.active = self.view.current_tick >= self.view.timelog.tick_count - 1

        data = self.data.get(start=self.view.current_tick, count=1)[0]
        if data is None:
            data = self.data.get_first()

        if(self.show_limits):
            g.color = Color(self.limit_color_val, self.limit_color_val, self.limit_color_val)
            txt_min = "%1.2f" % (-self.range)
            txt_max = "%1.2f" % (self.range)

            temp_font = g.font
            g.font = self.limits_font

            bounds_min = g.font.getStringBounds(txt_min, g.fontRenderContext)
            bounds_max = g.font.getStringBounds(txt_max, g.fontRenderContext)
            g.drawString(txt_max, 10 + bounds_min.width - bounds_max.width, self.resize_border + self.label_offset + bounds_max.height)
            g.drawString(txt_min, 10, self.height - self.resize_border - self.labels[0].getPreferredSize().height - bounds_min.height)

            g.font = temp_font

        for i, v in enumerate(data):
            while v > self.range * 1.1:
                self.range *= 2
            while v < -self.range * 1.1:
                self.range *= 2

        for i, v in enumerate(data):
            sv = int(v * 100.0 / self.range)
            if sv > 100:
                sv = 100
            if sv < -100:
                sv = -100
            if not self.sliders[i].valueIsAdjusting:
                self.sliders[i].value = sv
            self.labels[i].text = '%1.2f' % v
            self.sliders[i].enabled = self.active

        self.componentResized(None)

    def componentResized(self, e):
        w = self.width - self.resize_border * 2 - self.limit_width
        dw = w / len(self.sliders)
        x = (dw - self.sliders[0].minimumSize.width) / 2
        for i, slider in enumerate(self.sliders):
            slider.setLocation(self.limit_width + self.resize_border + x + i * dw, self.resize_border + self.label_offset)
            slider.setSize(slider.minimumSize.width, self.height - self.resize_border * 2 - 20 - self.label_offset)
            self.labels[i].setLocation(slider.x + slider.width / 2 - self.labels[i].width / 2, slider.y + slider.height)

    def componentHidden(self, e):
        pass

    def componentMoved(self, e):
        pass

    def componentShown(self, e):
        pass

    def save(self):
        info = core.DataViewComponent.save(self)

        if(self.auto_hide_limits):
            self.hide_limits(None)

        info['x'] = self.x            # Overwrite x and width to account for removed limits
        info['width'] = self.width
        info['range'] = self.range
        info['limits'] = self.auto_hide_limits
        info['limits_w'] = self.limit_width
        return info

    def restore(self, d):
        core.DataViewComponent.restore(self, d)
        self.range = d.get('range', 1.0)
        self.auto_hide_limits = d.get('limits', True)
        self.limit_width = d.get('limits_w', 0)
        self.popup_hide_limit.state = self.auto_hide_limits
        self.show_limits = not self.auto_hide_limits

    def mouseEntered(self, event):
        if(self.auto_hide_limits):
            self.disp_limits()
        core.DataViewComponent.mouseEntered(self, event)

    def mouseExited(self, event):
        if(self.auto_hide_limits):
            self.limit_hide_timer.start()
        core.DataViewComponent.mouseExited(self, event)

    def toggle_autohide(self, event):
        self.auto_hide_limits = event.source.state
        if(self.auto_hide_limits):
            self.limit_hide_timer.start()
        else:
            self.disp_limits()

    def disp_limits(self):
        if(not self.show_limits):
            limit_label = JLabel(("-%1.2f" % (self.range)))
            self.limit_width = limit_label.getPreferredSize().width - self.sliders[0].width / 2
            self.setSize(self.size.width + self.limit_width, self.size.height)
            self.setLocation(self.x - self.limit_width, self.y)

        self.limit_hide_timer.stop()
        self.limit_color_val = self.limit_color_def
        self.show_limits = True
        self.repaint()

    def hide_limits(self, event):
        if(self.show_limits):
            if(self.limit_color_val >= 1 - self.limit_color_step):
                self.limit_hide_timer.stop()
                self.setSize(self.size.width - self.limit_width, self.size.height)
                self.setLocation(self.x + self.limit_width, self.y)
                self.limit_width = 0
                self.show_limits = False
            else:
                self.limit_color_val += self.limit_color_step
                self.limit_color_val = min(self.limit_color_val, 1.0)
                self.limit_hide_timer.start()
        self.repaint()
    class TrackDevice(java.beans.PropertyChangeListener):
        import java
        import javax.swing
        from javax.swing import Timer

        delayTimer = None
        relayClicks = None

        # TrackDevice.init - Initialize a TrackDevice instance for a particular device
        #
        # aName          : Device name
        # aDevice        : JMRI device instance
        # aAllowedStates : Array of states we want to track, other states are ignored
        #
        def init(self, aName, aDevice, aAllowedStates, aLogFile, aParent):
            from javax.swing import Timer
            self.DeviceName = aName
            self.Device = aDevice
            self.DeviceNumber = self.DeviceName[2:self.DeviceName.find(":")]
            self.AllowedStates = aAllowedStates
            self.parent = aParent
            self.DeviceValue = self.AllowedStates[0]
            self.LogFile = aLogFile

            self.timeoutListener = self.TimeoutReceiver()
            self.timeoutListener.setCallBack(self.receiveTimeoutHandler)

            self.receiveTimer = Timer(100, self.timeoutListener)
            self.receiveTimer.setInitialDelay(10)

            self.receiveTimer.stop()
            self.receiveTimer.setRepeats(False)

            self.sendTimeoutListener = self.TimeoutReceiver2()
            self.sendTimeoutListener.setCallBack(self.sendTimeoutHandler)

            self.sendTimer = Timer(100, self.timeoutListener)
            self.sendTimer.setInitialDelay(10)
            self.sendTimer.stop()
            self.sendTimer.setRepeats(False)

            self.pauseTimeoutListener = self.TimeoutReceiver()
            self.pauseTimeoutListener.setCallBack(self.pauseTimeoutHandler)

            self.pauseTimer = Timer(100, self.pauseTimeoutListener)
            self.pauseTimer.setInitialDelay(10)

            self.pauseTimer.stop()
            self.pauseTimer.setRepeats(False)

            self.finalTimeoutListener = self.TimeoutReceiver()
            self.finalTimeoutListener.setCallBack(self.finalTimeoutHandler)
            self.finalTimer = Timer(100, self.finalTimeoutListener)
            self.finalTimer.setInitialDelay(10)
            self.finalTimer.stop()
            self.finalTimer.setRepeats(False)

            #            self.relayClicks = jmri.jmrit.Sound(jmri.util.FileUtil.getExternalFilename("preference:resources/sounds/EnhancedCTCRelayTrimmed.wav"))
            self.relayClicks = jmri.jmrit.Sound(
                "resources/sounds/Code-receive.wav")
            self.relaySend = jmri.jmrit.Sound("resources/sounds/Code-send.wav")

            return

        # TrackDevice.updateState - Track the device state while reading the old log
        #                           file.  Note the state but don't change the device
        #                           itself and don't log the changes to the new log file
        #                           (yet).
        #
        # aNewState : New device state.
        #
        def updateState(self, aNewState):
            print 'updateState ' + self.DeviceName + " to state = " + aNewState
            for i in range(len(self.AllowedStates)):
                if (aNewState == self.AllowedStates[i]):
                    self.DeviceValue = aNewState
                    self.Device.setValue(aNewState)
                    break

        # TrackDevice.propertyChange - Record state changes as a result of activities
        #                              elsewhere in JMRI
        #
        # aEvent : Event triggering the change (we don't actually look at the event...)
        #
        def propertyChange(self, aEvent):
            newValue = self.Device.getValue()
            print("***** In propertyChange")
            memories.getMemory("IM5:TVC").setValue("1")

            #
            #  Turn on Control Code indicator light
            codeSendSensor = sensors.getSensor("Code Send Indicator")
            codeSendSensor.setState(ACTIVE)

            #
            #  Start relay clicking sound
            self.relaySend.loop()

            #
            #  Start timer to keep code send light on and relays clicking for a while.
            ccdl = 15  #+  java.util.Random().nextInt(1) # Code transmission delay
            self.sendTimer.setDelay(ccdl * 1000)
            #self.sendTimer.start()

            self.parent.waitMsec(ccdl * 1000)

            self.relaySend.stop()
            codeSendSensor.setState(INACTIVE)

            if (newValue == self.DeviceValue):
                return

            for i in range(len(self.AllowedStates)):
                if (newValue == self.AllowedStates[i]):
                    self.DeviceValue = newValue
                    self.LogFile.write(self.DeviceName + " " +
                                       self.DeviceValue + "\n")
                    self.LogFile.flush()
                    break
            return

        # TrackDevice.setInitialDeviceState - After reading all of the old tracking file we
        #                                     now initialize the actual devices to their last
        #                                     known states and log these states into the new
        #                                     log file.
        #
        def setInitialDeviceState(self, logFile, parent):
            #       Uncomment the following print statement to display the list of devices being tracked.
            print "In setInitDeviceState, name = " + self.DeviceName + " value = " + self.DeviceValue
            self.LogFile = logFile
            ###            self.Device.setState(self.DeviceValue)
            self.Device.addPropertyChangeListener(self)
            #logStateChange2(self.DeviceName, self.DeviceState, False)
            logFile.write(self.DeviceName + " " + self.DeviceValue + "\n")

            signalId = "IS:" + self.DeviceNumber
            # Move the switch lever to the correct position
            sensors.getSensor(signalId + ":CB").setState(INACTIVE)
            if (self.DeviceValue == "N"):
                turnouts.provideTurnout("NT" +
                                        self.DeviceNumber).setState(CLOSED)
                self.parent.waitMsec(100)
                sensors.getSensor(signalId + ":NK").setState(ACTIVE)
                sensors.getSensor(signalId + ":L").setState(ACTIVE)
                sensors.getSensor(signalId + ":RK").setState(INACTIVE)

            else:
                turnouts.provideTurnout("NT" +
                                        self.DeviceNumber).setState(THROWN)
                self.parent.waitMsec(100)
                sensors.getSensor(signalId + ":NK").setState(INACTIVE)
                sensors.getSensor(signalId + ":RK").setState(ACTIVE)
                sensors.getSensor(signalId + ":L").setState(INACTIVE)

        class TimeoutReceiver(java.awt.event.ActionListener):
            cb = None

            def actionPerformed(self, event):
                if (self.cb != None):
                    self.cb(event)
                return

            def setCallBack(self, cbf):
                self.cb = cbf
                return

        class TimeoutReceiver2(java.awt.event.ActionListener):
            cb = None

            def actionPerformed(self, event):
                if (self.cb != None):
                    self.cb(event)
                return

            def setCallBack(self, cbf):
                self.cb = cbf
                return

        def sendTimeoutHandler(self, event):
            print "In send timeout handler"
            self.sendTimer.stop()
            self.relaySend.stop()
            sensors.getSensor("IS16:CCK").setState(INACTIVE)

            smdl = 5  #+  java.util.Random().nextInt(2) # Switch motor delay -

            self.pauseTimer.setInitialDelay(smdl * 100)
            self.pauseTimer.start()
            return

        #
        #  Timeout handler between send & receive.
        #  Turn panel indicators off & start indication code relay clicks.
        def pauseTimeoutHandler(self, event):
            self.pauseTimer.stop()

            sensors.getSensor("Code Receive Indicator").setState(ACTIVE)
            self.relayClicks.loop()
            newName = "IS:" + self.DeviceNumber
            sensors.getSensor(newName + ":NK").setState(INACTIVE)
            sensors.getSensor(newName + ":RK").setState(INACTIVE)
            signals.getSignalHead("VH:T" + str(self.DeviceNumber) +
                                  "N").setAppearance(DARK)
            signals.getSignalHead("VH:T" + str(self.DeviceNumber) +
                                  "R").setAppearance(DARK)

            icdl = 5  #+  java.util.Random().nextInt(3) # Indicator code delay

            self.receiveTimer.setInitialDelay(icdl * 100)
            self.receiveTimer.start()
            return

        #
        #  Final timeout handler....turn off Indication Code relay clicks and change indicator lights on panel.
        def receiveTimeoutHandler(self, event):
            # see which phase we think we are in
            self.receiveTimer.stop()

            sensors.getSensor("Code Receive Indicator").setState(INACTIVE)

            #
            #  Throw the turnout.  We should do this in an earlier timeout handler, but with the CTC panel lights hardwired to the tortoise motor,
            #  the lights change too soon.
            if (memories.getMemory("IM1:FB").getValue() == 0):
                if (self.Device.getValue() == "N"):
                    turnouts.provideTurnout("NT" +
                                            self.DeviceNumber).setState(CLOSED)
                else:
                    turnouts.provideTurnout("NT" +
                                            self.DeviceNumber).setState(THROWN)

            self.finalTimer.setInitialDelay(6000)
            self.finalTimer.start()

            return

        #
        #  Final timeout handler....turn off Indication Code relay clicks and change indicator lights on panel.
        def finalTimeoutHandler(self, event):
            # see which phase we think we are in
            self.finalTimer.stop()

            self.relayClicks.stop()
            sensors.getSensor("Code Receive Indicator").setState(INACTIVE)
            memories.getMemory("IM5:TVC").setValue("0")
            memories.getMemory("IM1:FB").setValue(0)
            return