def _handleInitializationComplete(self, args):
controllercaps = set()
if self._manager.isPrimaryController(self._homeId):
controllercaps.add("primaryController")
if self._manager.isStaticUpdateController(self._homeId):
controllercaps.add("staticUpdateController")
if self._manager.isBridgeController(self._homeId):
controllercaps.add("bridgeController")
self._controllerCaps = controllercaps
self._log.debug("Controller capabilities are: %s", controllercaps)
for node in self._nodes.values():
self._updateNodeCapabilities(node)
self._updateNodeCommandClasses(node)
self._updateNodeNeighbors(node)
self._updateNodeInfo(node)
self._updateNodeGroups(node)
self._updateNodeConfig(node)
self._initialized = True
self._log.info(
"OpenZWave initialization is complete. Found {0} Z-Wave Device Nodes ({1} sleeping)".format(
self.nodeCount, self.sleepingNodeCount
)
)
dispatcher.send(self.SIGNAL_SYSTEM_READY, **{"homeId": self._homeId})
self._manager.writeConfig(self._homeId)
def add(self, obj):
self._objects[obj.identifier] = obj
obj.world = self
typ = obj.type + "s"
self._objects_by_type[typ].append(obj)
dispatcher.send(signal=signals.NEW_OBJECT, sender=obj.__class__, obj=obj)
def updateerr(self,e):
print e.getTraceback()
dispatcher.send("update status", val=e.getErrorMessage())
if self.later and not self.later.cancelled and not self.later.called:
self.later.cancel()
self.later = reactor.callLater(1, self.update)
def _handleNodeChanged(self, args):
node = self._fetchNode(args['homeId'], args['nodeId'])
node._lastUpdate = time.time()
dispatcher.send(self.SIGNAL_NODE_ADDED, **{
'homeId': args['homeId'],
'nodeId': args['nodeId']
})
def updateLoop(self):
# print "updateLoop"
now = time.time()
self.recentUpdateTimes = self.recentUpdateTimes[-40:] + [now]
stats.recentFps = len(self.recentUpdateTimes) / (self.recentUpdateTimes[-1] - self.recentUpdateTimes[0] + .0001)
if now > self.lastStatLog + .2:
dispatcher.send('state', update={
'recentDeltas': sorted([round(t1 - t0, 4) for t0, t1 in
zip(self.recentUpdateTimes[:-1],
self.recentUpdateTimes[1:])]),
'recentFps': stats.recentFps})
self.lastStatLog = now
def done(sec):
# print "sec", sec
# delay = max(0, time.time() - (now + 1 / self.fps))
# print 'cl', delay
delay = 0.005
reactor.callLater(delay, self.updateLoop)
def err(e):
log.warn('updateLoop: %r', e)
reactor.callLater(2, self.updateLoop)
d = self.update()
d.addCallbacks(done, err)
def paintGL(self):
"""you set self.levels to dict and call tkRedraw"""
assert "GL_ARB_imaging" in glGetString(GL_EXTENSIONS).split()
start = time.time()
glClearColor(0.0, 0.0, 0.0, 0)
glClear(GL_COLOR_BUFFER_BIT | GL_ACCUM_BUFFER_BIT)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE) # add
# l=glGenLists(1)
# glNewList(l,GL_COMPILE)
# glEndList()
# drawing to glAccum might be good
layerTimes = []
layers = 0
for filename, mag in self.levels.items():
t = time.time()
layers += self.drawWithAlpha(self.image[filename], self.imageWidth, self.imageHeight, mag)
layerTimes.append(time.time() - t)
dispatcher.send("status", key="visibleLayers", value=str(layers))
dispatcher.send("status", key="redraw", value="%.1fms" % ((time.time() - start) * 1000))
def _handle_driver_ready(self, args):
'''
Called once OZW has queried capabilities and determined startup values. HomeID
and NodeID of controller are known at this point.
'''
self.home_id = args['home_id']
self._controllerNodeId = args['node_id']
self._controller = self._fetchNode(self.home_id,
self._controllerNodeId)
self._library_version = self._manager.getLibraryVersion(self.home_id)
self._library_type_name = self._manager.getLibraryTypeName(
self.home_id)
self._log.info(
'Driver ready. home_id is 0x%0.8x, controller node id is %d, using %s library version %s',
self.home_id, self._controllerNodeId, self._library_type_name,
self._library_version)
self._log.info('OpenZWave Initialization Begins.')
self._log.info(
'The initialization process could take several minutes. Please be patient.'
)
dispatcher.send(
self.SIGNAL_DRIVER_READY, **{
'home_id': self.home_id,
'node_id': self._controllerNodeId
})
def update(self):
if self._pressed.get(K_LEFT) and self._pressed.get(K_RIGHT):
x = 0
elif self._pressed.get(K_LEFT):
x = -1
elif self._pressed.get(K_RIGHT):
x = 1
else:
x = 0
if self._pressed.get(K_UP) and self._pressed.get(K_DOWN):
y = 0
elif self._pressed.get(K_UP):
y = -1
elif self._pressed.get(K_DOWN):
y = 1
else:
y = 0
dispatcher.send(signal=signals.MOVE_PLAYER,
sender=self.player,
x=self.player.x,
y=self.player.y,
vx=x,
vy=y)
def eval(self, current, t):
"""current graph is being passed as an optimization. It should be
equivalent to use self.graph in here."""
objs = list(current.objects(self.uri, L9['expression']))
if len(objs) > 1:
raise ValueError("found multiple expressions for %s: %s" %
(self.uri, objs))
expr = current.value(self.uri, L9['expression'])
if not expr:
dispatcher.send("expr_error", sender=self.uri, exc="no expr, using 0")
return 0
glo = self.curveset.globalsdict()
glo['t'] = t
glo = exprglo.exprGlobals(glo, t)
glo['getsub'] = lambda name: self.submasters.get_sub_by_name(name)
glo['chan'] = lambda name: Submaster.Submaster("chan", {get_dmx_channel(name): 1})
try:
self.lasteval = eval(expr, glo)
except Exception,e:
dispatcher.send("expr_error", sender=self.uri, exc=e)
return Submaster.Submaster("zero", {})
def dragTo(self, x, y, now=False, blade=False):
self.path.append((x, y, blade))
#print "drag to", x, y, len(self.path)
dispatcher.send("new path", path=self.path)
if now:
while self._step():
print "stepping now"
pass
def remove(self, identifier):
if identifier in self._objects:
obj = self._objects[identifier]
typ = obj.type + "s"
del self._objects[identifier]
self._objects_by_type[typ].remove(obj)
dispatcher.send(signal=signals.DEL_OBJECT, sender=obj)
def onFocus(self, *args):
curveNames = self.curveset.curveNamesInOrder()
currentExpr = self.entryBuffer.get_text()
usedCurves = [n for n in curveNames if n in currentExpr]
usedCurves.sort()
dispatcher.send("set_featured_curves", curveNames=usedCurves)
def on_exit(self, sender, final):
if sender is self.interpreter:
self.is_finished = True
for timer in self.compiler.timer_mapping.values():
eventlet.greenthread.cancel(timer)
del timer
dispatcher.disconnect(self, "signal_exit", self.interpreter)
dispatcher.send("signal_exit", self, final=final)
def dragTo(self, x, y, now=False, blade=False):
self.path.append((x, y, blade))
#print "drag to", x, y, len(self.path)
dispatcher.send("new path", path=self.path)
if now:
while self._step():
print "stepping now"
pass
def __publish(self, event, data=None, **args):
args.update({'event': event, 'data': data})
if 'signal' in args:
del args['signal']
if 'sender' in args:
del args['sender']
log.debug('publish signal=%s, args=%s' % (event, args))
dispatcher.send(signal=event, sender=self, **args)
def on_exit(self, sender, final):
if sender is self.interpreter:
self.is_finished = True
for timer in self.compiler.timer_mapping.values():
eventlet.greenthread.cancel(timer)
del timer
dispatcher.disconnect(self, "signal_exit", self.interpreter)
dispatcher.send("signal_exit", self, final=final)
def setLevels(self):
log.debug("sub update levels")
oldLevels = getattr(self, 'levels', {}).copy()
self.setLevelsFromGraph()
if oldLevels != self.levels:
log.debug("sub %s changed" % self.name)
# dispatcher too? this would help subcomposer
dispatcher.send("sub levels changed", sub=self)
def player_moved(self, identifier, x, y, vx, vy):
player = self.world.get(identifier)
dispatcher.send(signal=signals.MOVE_PLAYER,
sender=player,
x=x,
y=y,
vx=vx,
vy=vy)
return {}
def _handleNodeQueryComplete(self, args):
node = self._getNode(self._homeId, args['nodeId'])
self._updateNodeCapabilities(node)
self._updateNodeCommandClasses(node)
self._updateNodeNeighbors(node)
self._updateNodeInfo(node)
self._updateNodeGroups(node)
self._log.info('Z-Wave Device Node {0} is ready.'.format(node.id))
dispatcher.send(self.SIGNAL_NODE_READY, **{'homeId': self._homeId, 'nodeId': args['nodeId']})
def move(self, dx, dy):
if dx == dy == 0:
return
if abs(dx) > 1 or abs(dy) > 1:
print "========================= dx=%s dy=%s ======================" % (dx,dy)
self.xpos += dx
self.ypos += dy
dispatcher.send("coords", x=self.xpos, y=self.ypos)
#print "x=%d y=%d" % (self.xpos, self.ypos)
self.update()
def advance(self, dt):
for event in pygame.event.get():
if event.type == QUIT:
dispatcher.send(signal=signals.QUIT, sender=self)
else:
self.state.handle_event(event)
self.state.update(dt)
self.state.draw(self.screen)
pygame.display.flip()
def _handleValueChanged(self, args):
homeId = args['homeId']
controllerNodeId = args['nodeId']
valueId = args['valueId']
node = self._fetchNode(homeId, controllerNodeId)
node._sleeping = False
node._lastUpdate = time.time()
valueNode = self._getValueNode(homeId, controllerNodeId, valueId)
valueNode.update(args)
if self._initialized:
dispatcher.send(self.SIGNAL_VALUE_CHANGED, **{'homeId': homeId, 'nodeId': controllerNodeId, 'valueId': valueId})
def remote_send(self, **kw):
log.debug("received signal %r from hub", kw['signal'])
# see below for the reason for this translation
kw2 = {}
for k,v in kw.items():
if v == (None, "Anonymous"):
v = dispatcher.Anonymous
kw2[k] = v
dispatcher.send(_remoteSignal=True, **kw)
def remote_send(self, **kw):
log.debug("received signal %r from hub", kw['signal'])
# see below for the reason for this translation
kw2 = {}
for k, v in kw.items():
if v == (None, "Anonymous"):
v = dispatcher.Anonymous
kw2[k] = v
dispatcher.send(_remoteSignal=True, **kw)
def move(self, dx, dy):
if dx == dy == 0:
return
if abs(dx) > 1 or abs(dy) > 1:
print "========================= dx=%s dy=%s ======================" % (
dx, dy)
self.xpos += dx
self.ypos += dy
dispatcher.send("coords", x=self.xpos, y=self.ypos)
#print "x=%d y=%d" % (self.xpos, self.ypos)
self.update()
def _handleNodeQueryComplete(self, args):
node = self._getNode(self._homeId, args['nodeId'])
self._updateNodeCapabilities(node)
self._updateNodeCommandClasses(node)
self._updateNodeNeighbors(node)
self._updateNodeInfo(node)
self._updateNodeGroups(node)
self._log.info('Z-Wave Device Node {0} is ready.'.format(node.id))
dispatcher.send(self.SIGNAL_NODE_READY, **{
'homeId': self._homeId,
'nodeId': args['nodeId']
})
def eval(self,t):
if self.expr=="":
dispatcher.send("expr_error",sender=self,exc="no expr, using 0")
return 0
glo = self.curveset.globalsdict()
glo['t'] = t
glo = exprglo.exprGlobals(glo, t)
try:
self.lasteval = eval(self.expr,glo)
except Exception,e:
dispatcher.send("expr_error",sender=self,exc=e)
def record(actor, verb, *targets, **kwargs):
if not targets:
targets = kwargs.get('targets')
if not targets:
targets = [getSystem()]
if targets:
kwargs = kwargs.copy()
kwargs['targets'] = [target.key() for target in targets]
action = Action(actor=actor,
verb=verb,
**kwargs)
action.put()
dispatcher.send(signal=verb, sender=record, action=action)
return action
def _handleDriverReady(self, args):
'''
Called once OZW has queried capabilities and determined startup values. HomeID
and NodeID of controller are known at this point.
'''
self._homeId = args['homeId']
self._controllerNodeId = args['nodeId']
self._controller = self._fetchNode(self._homeId, self._controllerNodeId)
self._libraryVersion = self._manager.getLibraryVersion(self._homeId)
self._libraryTypeName = self._manager.getLibraryTypeName(self._homeId)
self._log.info('Driver ready. homeId is 0x%0.8x, controller node id is %d, using %s library version %s', self._homeId, self._controllerNodeId, self._libraryTypeName, self._libraryVersion)
self._log.info('OpenZWave Initialization Begins.')
self._log.info('The initialization process could take several minutes. Please be patient.')
dispatcher.send(self.SIGNAL_DRIVER_READY, **{'homeId': self._homeId, 'nodeId': self._controllerNodeId})
def send(signal, sender, *args, **kwargs):
"""
Sends a signal, causing connected handlers to be invoked.
Paramters:
:signal: Signal to be sent. This must be an instance of :class:`wlauto.core.signal.Signal`
or its subclasses.
:sender: The sender of the signal (typically, this would be ``self``). Some handlers may only
be subscribed to signals from a particular sender.
The rest of the parameters will be passed on as aruments to the handler.
"""
dispatcher.send(signal, sender, *args, **kwargs)
def scaled(self, t):
subexpr_eval = self.subexpr.eval(t)
# we prevent any exceptions from escaping, since they cause us to
# stop sending levels
try:
if isinstance(subexpr_eval, Submaster.Submaster):
# if the expression returns a submaster, just return it
return subexpr_eval
else:
# otherwise, return our submaster multiplied by the value
# returned
return self.submaster * subexpr_eval
except Exception, e:
dispatcher.send("expr_error", sender=self.subexpr, exc=str(e))
return Submaster.Submaster('Error: %s' % str(e), temporary=True)
def send(signal, sender, *args, **kwargs):
"""
Sends a signal, causing connected handlers to be invoked.
Paramters:
:signal: Signal to be sent. This must be an instance of :class:`wlauto.core.signal.Signal`
or its subclasses.
:sender: The sender of the signal (typically, this would be ``self``). Some handlers may only
be subscribed to signals from a particular sender.
The rest of the parameters will be passed on as aruments to the handler.
"""
dispatcher.send(signal, sender, *args, **kwargs)
def send_dmx(self,t):
dispatcher.send("curves to sliders", t=t)
scaledsubs=[]
for st in self.subterms:
scl = st.scaled(t)
scaledsubs.append(scl)
out = Submaster.sub_maxes(*scaledsubs)
levs = out.get_levels()
now=time.time()
if now-self.lastsendtime>5 or levs!=self.lastsendlevs:
dispatcher.send("output levels",val=levs)
dmxclient.outputlevels(out.get_dmx_list(),
twisted=1,clientid='curvecalc')
self.lastsendtime = now
self.lastsendlevs = levs
def update2(self,t):
# spot alsa soundcard offset is always 0, we get times about a
# second ahead of what's really getting played
#t = t - .7
dispatcher.send("update status",
val="ok: receiving time from music player")
if self.later and not self.later.cancelled and not self.later.called:
self.later.cancel()
self.later = reactor.callLater(.02, self.update)
self.recent_t = self.recent_t[-50:]+[t]
period = (self.recent_t[-1] - self.recent_t[0]) / len(self.recent_t)
dispatcher.send("update period", val=period)
self.send_dmx(t)
def findSubs(self):
current = set()
for s in self.graph.subjects(RDF.type, L9['Submaster']):
if self.graph.contains((s, RDF.type, L9['LocalSubmaster'])):
continue
log.debug("found sub %s", s)
if s not in self.submasters:
sub = self.submasters[s] = PersistentSubmaster(self.graph, s)
dispatcher.send("new submaster", sub=sub)
current.add(s)
for s in set(self.submasters.keys()) - current:
del self.submasters[s]
dispatcher.send("lost submaster", subUri=s)
log.info("findSubs finished, %s subs", len(self.submasters))
def _handleValueChanged(self, args):
homeId = args['homeId']
controllerNodeId = args['nodeId']
valueId = args['valueId']
node = self._fetchNode(homeId, controllerNodeId)
node._sleeping = False
node._lastUpdate = time.time()
valueNode = self._getValueNode(homeId, controllerNodeId, valueId)
valueNode.update(args)
if self._initialized:
dispatcher.send(
self.SIGNAL_VALUE_CHANGED, **{
'homeId': homeId,
'nodeId': controllerNodeId,
'valueId': valueId
})
def _start(self, doc):
if self.cancelled: return
from scxml.pyscxml import StateMachine
self.sm = StateMachine(doc,
sessionid=self.parentSessionid + "." + self.invokeid,
default_datamodel=self.default_datamodel,
log_function=lambda label, val: dispatcher.send(signal="invoke_log", sender=self, label=label, msg=val),
setup_session=False)
self.interpreter = self.sm.interpreter
self.sm.compiler.initData = self.initData
self.sm.compiler.parentId = self.parentId
self.sm.interpreter.parentId = self.parentId
dispatcher.send("created", sender=self, sm=self.sm)
self.sm._start_invoke(self.invokeid)
eventlet.spawn(self.sm.interpreter.mainEventLoop)
def exitInterpreter(self):
statesToExit = sorted(self.configuration, key=exitOrder)
for s in statesToExit:
for content in s.onexit:
self.executeContent(content)
for inv in s.invoke:
self.cancelInvoke(inv)
self.configuration.delete(s)
if isFinalState(s) and isScxmlState(s.parent):
if self.invokeId and self.parentId and self.parentId in self.dm.sessions:
self.send(["done", "invoke", self.invokeId], s.donedata(), self.invokeId, self.dm.sessions[self.parentId].interpreter.externalQueue)
self.logger.info("Exiting interpreter")
dispatcher.send("signal_exit", self, final=s.id)
return
dispatcher.send("signal_exit", self, final=None)
def exitInterpreter(self):
statesToExit = sorted(self.configuration, key=exitOrder)
for s in statesToExit:
for content in s.onexit:
self.executeContent(content)
for inv in s.invoke:
self.cancelInvoke(inv)
self.configuration.delete(s)
if isFinalState(s) and isScxmlState(s.parent):
if self.invokeId and self.parentId and self.parentId in self.dm.sessions:
self.send(["done", "invoke", self.invokeId], s.donedata(), self.invokeId, self.dm.sessions[self.parentId].interpreter.externalQueue)
self.logger.info("Exiting interpreter")
dispatcher.send("signal_exit", self, final=s.id)
self.exited = True
return
self.exited = True
dispatcher.send("signal_exit", self, final=None)
def hard_reset(self):
"""
Hard Reset a PC Z-Wave Controller.
Resets a controller and erases its network configuration settings. The
controller becomes a primary controller ready to add devices to a new network.
This command fires a lot of louie signals.
Louie's clients must disconnect from nodes and values signals
dispatcher.send(self._network.SIGNAL_NETWORK_RESETTED, **{'network': self._network})
"""
self._network.state=self._network.STATE_RESETTED
dispatcher.send(self._network.SIGNAL_NETWORK_RESETTED, \
**{'network': self._network})
self._network.manager.resetController(self._network.home_id)
time.sleep(5)
def onMsg(bus, msg):
if msg.src == sink and msg.structure.get_name() == 'pixbuf':
now = time.time()
pixbufTimes[:] = [t for t in pixbufTimes if t > now - 5] + [now]
dispatcher.send("videoStats",
txt="fps = %.1f" % (len(pixbufTimes) / 5.))
pbHigh = msg.structure['pixbuf']
pbLow = pbHigh.scale_simple(120, 90, gtk.gdk.INTERP_BILINEAR)
self.previewEnabled = self.pipelineSection.get_property(
"expanded")
if self.previewEnabled:
rawVideoWidget.set_from_pixbuf(pbHigh)
hue, mask = self.updateHuePic(pbLow)
matches = self.updateHueMatchPic(hue, mask)
centers = self.updateBlobPic(matches)
onFrame(centers, pbHigh)
return True
def zwcallback(self, args):
"""
The Callback Handler used when sendig commands to the controller.
Dispatch a louie message.
To do : add node in signal when necessary
:param args: A dict containing informations about the state of the controller
:type args: dict()
"""
logging.debug('Controller state change : %s', args)
state = args['state']
message = args['message']
if state == self.SIGNAL_CTRL_WAITING:
dispatcher.send(self.SIGNAL_CTRL_WAITING, \
**{'state': state, 'message': message, 'network': self._network, 'controller': self})
dispatcher.send(self.SIGNAL_CONTROLLER, \
**{'state': state, 'message': message, 'network': self._network, 'controller': self})
def onMsg(bus, msg):
if msg.src == sink and msg.structure.get_name() == 'pixbuf':
now = time.time()
pixbufTimes[:] = [t
for t in pixbufTimes if t > now - 5] + [now]
dispatcher.send("videoStats",
txt="fps = %.1f" % (len(pixbufTimes) / 5.))
pbHigh = msg.structure['pixbuf']
pbLow = pbHigh.scale_simple(120, 90, gtk.gdk.INTERP_BILINEAR)
self.previewEnabled = self.pipelineSection.get_property(
"expanded")
if self.previewEnabled:
rawVideoWidget.set_from_pixbuf(pbHigh)
hue, mask = self.updateHuePic(pbLow)
matches = self.updateHueMatchPic(hue, mask)
centers = self.updateBlobPic(matches)
onFrame(centers, pbHigh)
return True
def _step(self):
if not self.path:
if self.offTimer is None or self.offTimer.called:
self.offTimer = reactor.callLater(.1, self.off)
return False
if self.offTimer is not None and not self.offTimer.called:
self.offTimer.reset(.1)
goal = self.path[0]
goal = int(goal[0]), int(goal[1]), goal[2]
#print "at %s, to %s, %s lines left" % (
# (self.xpos, self.ypos), goal, len(self.path))
self.setBlade(goal[2])
if (self.xpos, self.ypos) == goal[:2]:
self.path.pop(0)
dispatcher.send("new path", path=self.path)
return True
self.move(cmp(goal[0], self.xpos), cmp(goal[1], self.ypos))
return True
def get_sync(self,
url,
data,
type=None,
content_type="application/x-www-form-urlencoded"):
try:
data = urlencode(data)
except: # data is probably a string to be send directly.
pass
headers = {"Content-Type": content_type}
if type and type.upper() not in ("POST", "GET"):
from restlib import RestfulRequest #@UnresolvedImport
req = RestfulRequest(url, data=data, method=type.upper())
else:
req = urllib2.Request(url, data, headers=headers)
opener = urllib2.build_opener(self)
eventlet.greenthread.sleep()
try:
f = opener.open(req, data=data)
if f.code is None or str(f.code)[0] == "2":
dispatcher.send(UrlGetter.HTTP_RESULT,
self,
result=f.read(),
source=url,
code=f.code)
else:
e = urllib2.HTTPError(
url, f.code,
"A code %s HTTP error has occurred when trying to send to target %s"
% (f.code, url), req.headers, f)
dispatcher.send(UrlGetter.HTTP_ERROR, self, exception=e)
# TODO: make sure we're supposed to listen to URLErrors
except (urllib2.URLError, ValueError), e:
dispatcher.send(UrlGetter.URL_ERROR, self, exception=e, url=url)
def poseMatch(self, positions1, positions2):
if not positions1 or not positions2:
return False
pairs = colorPairs(positions2.keys())
try:
angles = []
#print "\nuser:"******"%s to %s %.3f" % (c1[0], c2[0], row[-1])
#print ""
angles.append(row)
err = sum(x * x for x in map(diffAngle, zip(angles[0], angles[1])))
dispatcher.send("err", txt="error=%.3f" % err)
return err < .2
except KeyError:
return False
def _handleInitializationComplete(self, args):
controllercaps = set()
if self._manager.isPrimaryController(self._homeId):
controllercaps.add('primaryController')
if self._manager.isStaticUpdateController(self._homeId):
controllercaps.add('staticUpdateController')
if self._manager.isBridgeController(self._homeId):
controllercaps.add('bridgeController')
self._controllerCaps = controllercaps
self._log.debug('Controller capabilities are: %s', controllercaps)
for node in self._nodes.values():
self._updateNodeCapabilities(node)
self._updateNodeCommandClasses(node)
self._updateNodeNeighbors(node)
self._updateNodeInfo(node)
self._updateNodeGroups(node)
self._updateNodeConfig(node)
self._initialized = True
self._log.info(
"OpenZWave initialization is complete. Found {0} Z-Wave Device Nodes ({1} sleeping)"
.format(self.nodeCount, self.sleepingNodeCount))
dispatcher.send(self.SIGNAL_SYSTEM_READY, **{'homeId': self._homeId})
self._manager.writeConfig(self._homeId)
from twisted.internet import reactor
import hubclient
from louie import dispatcher
hubclient.connect()
dispatcher.send("signal one")
dispatcher.send("timed test")
def listen():
print "i got response"
dispatcher.connect(listen, "timed test response")
reactor.run()
def callback(self, n):
self._homeId = n['homeId']
dispatcher.send(n['type'], **n['valueId'])
def send(sender, signal, *args, **kwargs):
dispatcher.send(signal, sender, *args, **kwargs)
def _send_stop(self):
dispatcher.send(StopSignal, self)
def __publish(self, event, **args):
args.update({'event': event})
log.debug('publish signal=%s, args=%s' % (event, args))
dispatcher.send(signal=event, sender=self, **args)
def _send_point_nb(self, point_nb):
dispatcher.send(PointNbSignal, self, point_nb)
