def _connect_services(self):
"""Connect to all services required by ALTactileGesture"""
self.services_connected = qi.Promise()
services_connected_fut = self.services_connected.future()
def get_services():
"""Attempt to get all services"""
try:
self.memory = self.session.service('ALMemory')
self.prefs = self.session.service('ALPreferenceManager')
self.logger.info('got references to all services')
self.services_connected.setValue(True)
except RuntimeError as e:
self.logger.warning('missing service:\n {}'.format(e))
get_services_task = qi.PeriodicTask()
get_services_task.setCallback(get_services)
get_services_task.setUsPeriod(int(2 * 1000000)) # check every 2s
get_services_task.start(True)
try:
services_connected_fut.value(30 * 1000) # timeout = 30s
get_services_task.stop()
except RuntimeError:
get_services_task.stop()
self.logger.info('Failed to reach all services after 30 seconds')
raise RuntimeError
def _search_gestures(self):
"""
Compare inputted sequence to all gestures to find match
Algorithm:
1. async call _check_sequence on for all gestures
(i.e. gestures that match the current hold status and are not unset custom gestures)
-> _check_sequence() will fullfill promise with the gesture if matched; else None
2. Build list of all futures whose value is a matched sequence
3. Return the gesture whose match is the closest the sequence prototype
it matched (i.e. smallest difference)
"""
futures = []
las = len(self.active_sequence)
# For every sequence; start check asynchronously
for gesture in self.all_gestures:
if gesture.hold == self.active_hold:
p = qi.Promise()
futures.append(p.future())
qi. async (self._check_sequence, self.active_sequence, las,
gesture, p)
# Walks through futures list; waits on each promise to be fullfiled
vf = (f.value() for f in futures if f.value()[0])
# Returns gesture corresponding to min diff value in vf above
# If vf is empty, returns (None, 0)
return reduce(lambda x, y: min((x, y), key=op.itemgetter(1)), vf,
next(vf, (None, 0)))[0]
def _connect_services(self):
"""
Connect to all services required by BarcodeReader.
"""
self.logger.info('Connecting services...')
self.services_connected = qi.Promise()
services_connected_fut = self.services_connected.future()
def get_services():
"""Attempt to get all services"""
try:
self.mem = self.session.service('ALMemory')
self.vid = self.session.service("ALVideoDevice")
self.logger.info('All services are now connected')
self.services_connected.setValue(True)
except RuntimeError as e:
self.logger.warning('Missing service:\n {}'.format(e))
get_services_task = qi.PeriodicTask()
get_services_task.setCallback(get_services)
get_services_task.setUsPeriod(int(2 * 1000000)) # check every 2s
get_services_task.start(True)
try:
services_connected_fut.value(30 * 1000) # timeout = 30s
get_services_task.stop()
except RuntimeError:
get_services_task.stop()
self.logger.error('Failed to reach all services after 30 seconds.')
raise RuntimeError
def connect_services(self):
# connect all services required by your module
# done in async way over 30s,
# so it works even if other services are not yet ready when you start your module
# this is required when the service is autorun as it may start before other modules...
self.logger.info('Connecting services...')
self.services_connected = qi.Promise()
services_connected_fut = self.services_connected.future()
def get_services():
try:
self.memory = self.session.service('ALMemory')
self.dialog = self.session.service('ALDialog')
# connect other services if needed...
self.logger.info('All services are now connected')
self.services_connected.setValue(True)
except RuntimeError as e:
self.logger.warning(
'Still missing some service:\n {}'.format(e))
get_services_task = qi.PeriodicTask()
get_services_task.setCallback(get_services)
get_services_task.setUsPeriod(int(2 * 1000000)) # check every 2s
get_services_task.start(True)
try:
services_connected_fut.value(30 * 1000) # timeout = 30s
get_services_task.stop()
except RuntimeError:
get_services_task.stop()
self.logger.error('Failed to reach all services after 30 seconds')
raise RuntimeError
def bind_retfutint(self):
p = qi.Promise("(i)")
t = threading.Thread(target=setValue, args=(
p,
42,
))
t.start()
return p.future()
def test_future_strand():
obj = Stranded(30)
prom = qi.Promise()
for i in range(30):
prom.future().addCallback(obj.cb)
prom.setValue(None)
obj.end.future().value()
def _waitForTabletReconnection(self, t):
""" Wait for the ALTabletService reconnection for x secunds
Parameters:
t (int) - the time to wait the reconnection in sec
"""
self.logger.info(
"ALTabletService not found, wait %ss for reconnection ..." % t)
self.promiseWaitingTabletReconnection = qi.Promise()
qi. async (self._cancelWaitForTabletReconnection, delay=t * 1000000)
self.promiseWaitingTabletReconnection.future().wait()
self.promiseWaitingTabletReconnection = None
def retfutmap(self):
p = qi.Promise()
t = threading.Thread(target=setValue,
args=(
p,
{
'titi': 'toto',
"foo": "bar"
},
))
t.start()
return p.future()
def run(self):
self.logger.info("run")
self.init_variables()
self.check_variables()
self.promise = qi.Promise(self._cancel)
self.reason = None
self.signal_id = self.move_failed_subscriber.signal.connect(
self._on_move_failed)
self.robot_position_begin = almath.Pose2D(
self.ALMotion.getRobotPosition(True))
self.task.start(True)
return self.promise.future()
def __init__(self, application):
self.application = application
self.session = application.session
self.service_name = self.__class__.__name__
# Getting a logger. Logs will be in /var/log/naoqi/servicemanager/{application id}.{service name}
self.logger = qi.Logger(self.service_name)
self.logger.info("Initializing...")
self.handDetect = False
def awaitServiceStartup(p):
try:
self.motion = self.session.service("ALMotion")
self.posture = self.session.service("ALRobotPosture")
self.speech = self.session.service("ALTextToSpeech")
self.memory = self.session.service("ALMemory")
self.speakingMovement = self.session.service(
"ALSpeakingMovement")
self.listeningMovement = self.session.service(
"ALListeningMovement")
self.backgroundMovement = self.session.service(
"ALBackgroundMovement")
except RuntimeError:
self.logger.info("Services not found")
return
self.logger.info("Services found")
p.setValue("SERVICES_READY")
p = qi.Promise()
f = p.future()
pt = qi.PeriodicTask()
pt.setCallback(functools.partial(awaitServiceStartup, p))
pt.setUsPeriod(2000000)
pt.start(True)
if f.value(30000) == "SERVICES_READY":
self.service_id = self.session.registerService(
self.service_name, self)
self.logger.info("Initialized!")
else:
self.logger.info("Initialization failed!")
pt.stop()
def show_prompt():
"""
This example uses the executeJS method.
To Test ALTabletService, you need to run the script ON the robot.
"""
global exit
global file
# Get the service ALTabletService.
try:
# Javascript script for displaying a prompt
# ALTabletBinding is a javascript binding inject in the web page displayed on the tablet
script = """
var name = prompt("Write down your email to receive our SMILE-Newsletter ", "*****@*****.**");
ALTabletBinding.raiseEvent(name)
"""
# Don't forget to disconnect the signal at the end
signalID = 0
# function called when the signal onJSEvent is triggered
# by the javascript function ALTabletBinding.raiseEvent(name)
print('Defining callback')
def callback(event):
global exit
if not str(event) == '*****@*****.**':
if event:
print(event)
file.write(str(event) + '\n')
tts.say('Thank you')
exit.set()
promise = qi.Promise()
print('Connecting callback')
# attach the callback function to onJSEvent signal
signalID = tabletService.onJSEvent.connect(callback)
# inject and execute the javascript in the current web page displayed
print('Executing script')
tabletService.executeJS(script)
exit.clear()
exit.wait()
except Exception, e:
print "Error was:", e
file.close()
def main(session):
"""
This example uses the executeJS method.
To Test ALTabletService, you need to run the script ON the robot.
"""
# Get the service ALTabletService.
tabletService = session.service("ALTabletService")
try:
# Display a local web page located in boot-config/html folder
# The ip of the robot from the tablet is 198.18.0.1
tabletService.showWebview(
"http://198.18.0.1/apps/boot-config/preloading_dialog.html")
time.sleep(3)
# Javascript script for displaying a prompt
# ALTabletBinding is a javascript binding inject in the web page displayed on the tablet
script = """
var name = prompt("Please enter your name", "Harry Pepper");
ALTabletBinding.raiseEvent(name)
"""
# Don't forget to disconnect the signal at the end
signalID = 0
# function called when the signal onJSEvent is triggered
# by the javascript function ALTabletBinding.raiseEvent(name)
def callback(event):
print "your name is:", event
promise.setValue(True)
promise = qi.Promise()
# attach the callback function to onJSEvent signal
signalID = tabletService.onJSEvent.connect(callback)
# inject and execute the javascript in the current web page displayed
tabletService.executeJS(script)
try:
promise.future().hasValue(30000)
except RuntimeError:
raise RuntimeError('Timeout: no signal triggered')
except Exception, e:
print "Error was:", e
def test_future_partials_strand():
obj = Stranded(50)
prom = qi.Promise()
for i in range(10):
prom.future().addCallback(obj.cb)
for i in range(10):
prom.future().addCallback(partial(obj.cbn, 1))
for i in range(10):
prom.future().addCallback(partial(partial(obj.cbn, 1), 2))
for i in range(10):
prom.future().addCallback(partial(partial(Stranded.cbn, obj, 1), 2))
for i in range(10):
prom.future().addCallback(partial(Stranded.cbn, obj, 1))
prom.setValue(None)
obj.end.future().value()
def test_return_empty_object(session_to_process_service_endpoint):
service_name, service_session = session_to_process_service_endpoint
log = logging.getLogger("test_return_empty_object")
obj = service_session.service(service_name)
prom = qi.Promise()
def callback(obj):
try:
log.info("object is valid: {}.".format(obj.isValid()))
prom.setValue(not obj.isValid())
except Exception as err:
prom.setError(str(err))
except:
prom.setError("Unknown exception.")
obj.signal.connect(callback)
obj.resetObject()
obj.emit()
assert prom.future().value()
def wrapper(self, *args, **kwds):
promise = qi.Promise(_cancel)
future = promise.future()
queued_tmstp = time.time()
def runner():
if not promise.future().isCanceled():
try:
exec_tmstp = time.time()
if expire_delay != -1 and exec_tmstp - queued_tmstp > expire_delay:
logger.info("Expired %s%s, do not exec" %
(method.__name__, args))
promise.setError(
"Could not exec method, it expired")
return
res = method(self, *args, **kwds)
if not promise.future().isCanceled():
promise.setValue(res)
except Exception, e:
logger.error(traceback.format_exc())
if not promise.future().isCanceled():
promise.setError(str(e))
def test_all_strand():
obj = Stranded(81)
sig = qi.Signal("m")
prop = qi.Property("m")
prom = qi.Promise()
per = qi.PeriodicTask()
per.setCallback(partial(obj.cb, None))
per.setUsPeriod(10000)
for i in range(20):
prom.future().addCallback(obj.cb)
for i in range(20):
sig.connect(obj.cb)
for i in range(20):
prop.connect(obj.cb)
per.start(True)
sig(None)
prop.setValue(42)
prom.setValue(None)
for i in range(20):
qi. async (partial(obj.cb, None))
obj.end.future().value()
per.stop()
def wait_for(self, event, subscribe=False):
"""Block until a certain event is raised, and returns it's value.
If you pass subscribe=True, ALMemory.subscribeToEvent will be called
(sometimes necessary for side effects, i.e. WordRecognized).
This will block a thread so you should avoid doing this too often!
"""
if self.wait_promise:
# there was already a wait in progress, cancel it!
self.wait_promise.setCanceled()
self.wait_promise = qi.Promise()
if subscribe:
connection_id = self.subscribe(event, "EVENTHELPER",
self._on_wait_event)
elif "." in event: # it's a signal
connection_id = self.connect(event, self._on_wait_signal)
else:
connection_id = self.connect(event, self._on_wait_event)
try:
result = self.wait_promise.future().value()
finally:
self.disconnect(event, connection_id)
return result
def connect_services(self, timeout):
"""Connect to all services required.
:param timeout: time in seconds after wich acquiring services is
abandonned."""
self.services_connected = qi.Promise()
services_connected_fut = self.services_connected.future()
timeout = int(max([1, timeout]) * 1000)
period = int(min([2, timeout / 2]) * 1000000)
self.logger.info('Timeout: {} ms'.format(timeout))
self.logger.info('Period: {} us'.format(period))
get_services_task = qi.PeriodicTask()
get_services_task.setCallback(self.get_services)
get_services_task.setUsPeriod(period)
get_services_task.start(True)
try:
services_connected_fut.value(timeout)
get_services_task.stop()
except RuntimeError:
get_services_task.stop()
raise RuntimeError(
'Failed to reach all services after {} ms'.format(timeout))
def fut(self):
p = qi.Promise()
#p.setValue(42)
threading.Thread(target=makeIt, args=[p]).start()
return p.future()
def __init__(self):
self.running = True
self.promise = qi.Promise()
self.future = self.promise.future()
self._exception = ""
self.lock = threading.Lock()
def __dialog_reinit_promise(self):
if self.__dialog_promise is not None and not self.__dialog_promise.future(
).isFinished():
self.__dialog_promise.setCanceled()
self.__dialog_promise = qi.Promise()
def __init__(self, max):
self.calling = False
self.counter = 0
self.max = max
self.end = qi.Promise()
