Beispiel #1
0
class PulseParam(IoParamBase):
    def __init__(self, *args):
        self.defaultParams = {
            'description': '',
            'subType': '',
            'default': False,
            'sendMessageOnChange': False,
            'toggleTimeOut': 30
        }
        IoParamBase.__init__(self, *args)
        self.timer = False

    def setValue(self, newValue):
        newValue = self.constrain(newValue)
        self.value = newValue
        if self.params['sendMessageOnChange']:
            app.messenger.putMessage(
                "output%s_%s" % (self.parentId, self.indexId), self.value)
        if newValue:
            if self.timer:
                self.timer.refresh()
            else:
                self.timer = Timer(False, self.params['toggleTimeOut'],
                                   self.setValue, [False])

    def constrain(self, value):
        return bool(value)

    def stop(self):
        if self.timer:
            self.timer.stop()
Beispiel #2
0
class RandomPulseInput(InputBase):
    def __init__(self, *args):
        InputBase.__init__(self, *args)
        self.checkTimer = Timer(True, 200, self.doCheck)
        self.numPulses = 1
        self.onStates = [False]
        self.offTimers = [
            Timer(False, self.inParams[1].getValue(), self.turnOff, (0, ))
        ]

    def stop(self):
        self.checkTimer.stop()
        for i in range(self.numPulses):
            self.offTimers[i].stop()
        InputBase.stop(self)

    def doCheck(self):
        for i in range(self.numPulses):
            if random.randint(0, self.inParams[0].getValue()) < 2:
                self.outParams[i].setValue(True)
                self.offTimers[i].changeInterval(
                    random.randint(
                        min(self.inParams[1].getValue(),
                            self.inParams[2].getValue()),
                        max(self.inParams[1].getValue(),
                            self.inParams[2].getValue())))
                self.offTimers[i].refresh()

    def turnOff(self, index):
        self.outParams[index].setValue(False)
Beispiel #3
0
 def __init__(self, *args):
     InputBase.__init__(self, *args)
     self.checkTimer = Timer(True, 200, self.doCheck)
     self.numPulses = 1
     self.onStates = [False]
     self.offTimers = [
         Timer(False, self.inParams[1].getValue(), self.turnOff, (0, ))
     ]
Beispiel #4
0
 def __init__(self, moduleConfig):
     self.initialized = False
     self.moduleConfig = deepcopy(moduleConfig)
     self.refreshTimer = False
     if 'resendDataInterval' in self.moduleConfig['protocol'].keys(
     ) and self.moduleConfig['protocol']['resendDataInterval']:
         self.refreshTimer = Timer(
             True, self.moduleConfig['protocol']['resendDataInterval'],
             self.resendOnStates)
Beispiel #5
0
 def setValue(self, newValue):
     newValue = self.constrain(newValue)
     self.value = newValue
     if self.params['sendMessageOnChange']:
         app.messenger.putMessage(
             "output%s_%s" % (self.parentId, self.indexId), self.value)
     if newValue:
         if self.timer:
             self.timer.refresh()
         else:
             self.timer = Timer(False, self.params['toggleTimeOut'],
                                self.setValue, [False])
	def setValue(self, newValue):
		newValue = self.constrain(newValue)
		self.value = newValue
		if self.params['sendMessageOnChange']:
			app.messenger.putMessage("output%s_%s" %(self.parentId, self.indexId), self.value)
		if newValue:
			if self.timer:
				self.timer.refresh()
			else:
				self.timer = Timer(False, self.params['toggleTimeOut'], self.setValue, [False])
class SculptureModuleBase():
	def __init__ (self, moduleConfig):
		self.initialized = False
		self.moduleConfig = deepcopy(moduleConfig)
		self.refreshTimer = False
		if 'resendDataInterval' in self.moduleConfig['protocol'].keys() and self.moduleConfig['protocol']['resendDataInterval']:
			self.refreshTimer = Timer(True, self.moduleConfig['protocol']['resendDataInterval'], self.resendOnStates)

	def stop(self):
		if self.refreshTimer:
			self.refreshTimer.stop()

	
	def doCommand(self, command):
		functionName = command.pop(0)
		function = getattr(self, functionName)
		return function(*command)
		
	def getId(self):
		return self.moduleConfig['moduleId'] + 'Module'
Beispiel #8
0
 def __init__(self, params, *args):
     params = utils.multiExtendSettings(inputTypes['random pulse'],
                                        inputTypes['randomPulse multi'],
                                        params)
     self.numPulses = params['number']
     for inputIndex in range(len(params['inParams'])):
         params['inParams'][inputIndex]['relevance'] = [
             i for i in range(self.numPulses)
         ]
     params['outParams'] = [{
         'type': 'toggle',
         'sendMessageOnChange': True,
         'description': 'channel%s' % (i)
     } for i in range(self.numPulses)]
     InputBase.__init__(self, params, *args)
     self.checkTimer = Timer(True, 200, self.doCheck)
     self.onStates = [False for i in range(self.numPulses)]
     self.offTimers = [
         Timer(False, self.inParams[1].getValue(), self.turnOff, (i, ))
         for i in range(self.numPulses)
     ]
 def __init__(self, *args):
     self.inputParams = {
         'poofButton': {
             'descriptionInPattern': 'Poof!',
             'type': 'pulse',
             'subType': 'button',
             'bindToFunction': 'poofButton'
         },
         'stayOnTime': {
             'descriptionInPattern': 'Time to stay on for(ms)',
             'type': 'value',
             'subType': 'int',
             'min': 100,
             'max': 1000,
             'default': 200
         },
     }
     PatternBase.__init__(self, *args)
     self.patternName = 'Allpoof'
     self.timer = Timer(False, self.inputs.stayOnTime, self.turnOff)
     self.poofState = False
Beispiel #10
0
class SculptureModuleBase():
    def __init__(self, moduleConfig):
        self.initialized = False
        self.moduleConfig = deepcopy(moduleConfig)
        self.refreshTimer = False
        if 'resendDataInterval' in self.moduleConfig['protocol'].keys(
        ) and self.moduleConfig['protocol']['resendDataInterval']:
            self.refreshTimer = Timer(
                True, self.moduleConfig['protocol']['resendDataInterval'],
                self.resendOnStates)

    def stop(self):
        if self.refreshTimer:
            self.refreshTimer.stop()

    def doCommand(self, command):
        functionName = command.pop(0)
        function = getattr(self, functionName)
        return function(*command)

    def getId(self):
        return self.moduleConfig['moduleId'] + 'Module'
class RandomPulseInput(InputBase):
	def __init__(self, *args):
		InputBase.__init__(self, *args)
		self.checkTimer = Timer(True, 200, self.doCheck)
		self.numPulses = 1
		self.onStates = [False]
		self.offTimers = [Timer(False, self.inParams[1].getValue(), self.turnOff, (0,))]

	def stop(self):
		self.checkTimer.stop()
		for i in range(self.numPulses):
			self.offTimers[i].stop()
		InputBase.stop(self)
		
	def doCheck(self):
		for i in range(self.numPulses):
			if random.randint(0, self.inParams[0].getValue()) < 2:
				self.outParams[i].setValue(True)
				self.offTimers[i].changeInterval(random.randint(min(self.inParams[1].getValue(), self.inParams[2].getValue()), max(self.inParams[1].getValue(), self.inParams[2].getValue())))
				self.offTimers[i].refresh()
				
	def turnOff(self, index):
		self.outParams[index].setValue(False)
class PulseParam(IoParamBase):
	def __init__(self, *args):
		self.defaultParams = {'description' : '', 'subType' : '', 'default' : False, 'sendMessageOnChange' : False, 'toggleTimeOut' : 30}
		IoParamBase.__init__(self, *args)
		self.timer = False

	def setValue(self, newValue):
		newValue = self.constrain(newValue)
		self.value = newValue
		if self.params['sendMessageOnChange']:
			app.messenger.putMessage("output%s_%s" %(self.parentId, self.indexId), self.value)
		if newValue:
			if self.timer:
				self.timer.refresh()
			else:
				self.timer = Timer(False, self.params['toggleTimeOut'], self.setValue, [False])

	def constrain(self, value):
		return bool(value)

	def stop(self):
		if self.timer:
			self.timer.stop()
	def __init__(self, *args):
		self.inputParams = {
			'poofButton' : {
				'descriptionInPattern' : 'Poof!',
				'type' : 'pulse',
				'subType' : 'button',
				'bindToFunction' : 'poofButton'
			},
			'stayOnTime' : {
				'descriptionInPattern' : 'Time to stay on for(ms)',
				'type' : 'value',
				'subType' : 'int',
				'min' : 100,
				'max' : 1000,
				'default' : 200
			},
		}
		PatternBase.__init__(self, *args)
		self.patternName = 'Allpoof'
		self.timer = Timer(False, self.inputs.stayOnTime, self.turnOff)
		self.poofState = False
class AllPoof(PatternBase):
	def __init__(self, *args):
		self.inputParams = {
			'poofButton' : {
				'descriptionInPattern' : 'Poof!',
				'type' : 'pulse',
				'subType' : 'button',
				'bindToFunction' : 'poofButton'
			},
			'stayOnTime' : {
				'descriptionInPattern' : 'Time to stay on for(ms)',
				'type' : 'value',
				'subType' : 'int',
				'min' : 100,
				'max' : 1000,
				'default' : 200
			},
		}
		PatternBase.__init__(self, *args)
		self.patternName = 'Allpoof'
		self.timer = Timer(False, self.inputs.stayOnTime, self.turnOff)
		self.poofState = False

	def poofButton(self, *args):
		if self.inputs.poofButton:
			self.timer.changeInterval(self.inputs.stayOnTime)
			self.timer.refresh()
			self.poofState = True
			self.requestUpdate()
	
	def turnOff(self):
		self.poofState = False
		self.requestUpdate()

	def getState(self, row, col):
		return self.poofState
		
	def stop(self):
		self.timer.stop()
		PatternBase.stop(self)
class AllPoof(PatternBase):
    def __init__(self, *args):
        self.inputParams = {
            'poofButton': {
                'descriptionInPattern': 'Poof!',
                'type': 'pulse',
                'subType': 'button',
                'bindToFunction': 'poofButton'
            },
            'stayOnTime': {
                'descriptionInPattern': 'Time to stay on for(ms)',
                'type': 'value',
                'subType': 'int',
                'min': 100,
                'max': 1000,
                'default': 200
            },
        }
        PatternBase.__init__(self, *args)
        self.patternName = 'Allpoof'
        self.timer = Timer(False, self.inputs.stayOnTime, self.turnOff)
        self.poofState = False

    def poofButton(self, *args):
        if self.inputs.poofButton:
            self.timer.changeInterval(self.inputs.stayOnTime)
            self.timer.refresh()
            self.poofState = True
            self.requestUpdate()

    def turnOff(self):
        self.poofState = False
        self.requestUpdate()

    def getState(self, row, col):
        return self.poofState

    def stop(self):
        self.timer.stop()
        PatternBase.stop(self)
class TimerPulseInput(InputBase):
	def __init__(self, *args):
		InputBase.__init__(self, *args)
		self.timer = Timer(True, self.inParams[0].getValue(), getattr(self, 'sendPulse'))

	def stop(self):
		self.timer.stop()
		InputBase.stop(self)

	def refresh(self):
		self.timer.refresh()

	def sendPulse(self):
		self.outParams[0].setValue(True)


	def setInputValue(self, *args):
		InputBase.setInputValue(self, *args)
		self.timer.changeInterval(self.inParams[0].getValue())
		
	def updateOutputValues(self):
		pass
Beispiel #17
0
class TimerPulseInput(InputBase):
    def __init__(self, *args):
        InputBase.__init__(self, *args)
        self.timer = Timer(True, self.inParams[0].getValue(),
                           getattr(self, 'sendPulse'))

    def stop(self):
        self.timer.stop()
        InputBase.stop(self)

    def refresh(self):
        self.timer.refresh()

    def sendPulse(self):
        self.outParams[0].setValue(True)

    def setInputValue(self, *args):
        InputBase.setInputValue(self, *args)
        self.timer.changeInterval(self.inParams[0].getValue())

    def updateOutputValues(self):
        pass
	def __init__ (self, moduleConfig):
		self.initialized = False
		self.moduleConfig = deepcopy(moduleConfig)
		self.refreshTimer = False
		if 'resendDataInterval' in self.moduleConfig['protocol'].keys() and self.moduleConfig['protocol']['resendDataInterval']:
			self.refreshTimer = Timer(True, self.moduleConfig['protocol']['resendDataInterval'], self.resendOnStates)
	def __init__(self, *args):
		InputBase.__init__(self, *args)
		self.timer = Timer(True, self.inParams[0].getValue(), getattr(self, 'sendPulse'))
Beispiel #20
0
 def __init__(self, *args):
     InputBase.__init__(self, *args)
     self.timer = Timer(True, self.inParams[0].getValue(),
                        getattr(self, 'sendPulse'))
	def __init__(self, *args):
		InputBase.__init__(self, *args)
		self.checkTimer = Timer(True, 200, self.doCheck)
		self.numPulses = 1
		self.onStates = [False]
		self.offTimers = [Timer(False, self.inParams[1].getValue(), self.turnOff, (0,))]
Beispiel #22
0
 def setItemState(self, addr, state):
     state = app.isSafeModeOff() and state
     self.individualToggleStates[addr[0]][addr[1]] = state
     if state:
         Timer(False, 500, self.setItemState, (addr, False), True)
     self.doUpdates()