169 lines
6.4 KiB
Python
169 lines
6.4 KiB
Python
from __future__ import unicode_literals # So that we can log texts with Unicode characters
|
|
import logging
|
|
from threading import Thread
|
|
|
|
import Queue
|
|
import zmq
|
|
|
|
from robot_interface.endpoints.receiver_base import ReceiverBase
|
|
from robot_interface.state import state
|
|
from robot_interface.core.config import settings
|
|
from robot_interface.endpoints.gesture_settings import GestureTags
|
|
|
|
|
|
class ActuationReceiver(ReceiverBase):
|
|
"""
|
|
The actuation receiver endpoint, responsible for handling speech and gesture requests.
|
|
|
|
:param zmq_context: The ZeroMQ context to use.
|
|
:type zmq_context: zmq.Context
|
|
|
|
:param port: The port to use.
|
|
:type port: int
|
|
|
|
:ivar _tts_service: The text-to-speech service object from the Qi session.
|
|
:vartype _tts_service: qi.Session | None
|
|
|
|
:ivar _animation_service: The animation/gesture service object from the Qi session.
|
|
:vartype _animation_service: qi.Session | None
|
|
"""
|
|
def __init__(self, zmq_context, port=settings.agent_settings.actuation_receiver_port):
|
|
super(ActuationReceiver, self).__init__("actuation")
|
|
self.create_socket(zmq_context, zmq.SUB, port)
|
|
self.socket.setsockopt_string(zmq.SUBSCRIBE, u"") # Causes block if given in options
|
|
self._tts_service = None
|
|
self._animation_service = None
|
|
self._message_queue = Queue.Queue()
|
|
self.message_thread = Thread(target=self._handle_messages)
|
|
self.message_thread.start()
|
|
|
|
def _handle_speech(self, message):
|
|
"""
|
|
Handle a speech actuation request.
|
|
|
|
:param message: The message to handle, must contain properties "endpoint" and "data".
|
|
:type message: dict
|
|
"""
|
|
text = message.get("data")
|
|
if not text:
|
|
logging.warn("Received message to speak, but it lacks data.")
|
|
return
|
|
|
|
if not isinstance(text, (str, unicode)):
|
|
logging.warn("Received message to speak but it is not a string.")
|
|
return
|
|
|
|
logging.debug("Received message to speak: {}".format(text))
|
|
|
|
if not state.qi_session: return
|
|
# If state has a qi_session, we know that we can import qi
|
|
import qi # Takes a while only the first time it's imported
|
|
|
|
if not self._tts_service:
|
|
self._tts_service = state.qi_session.service("ALTextToSpeech")
|
|
|
|
if message.get("is_priority"):
|
|
# Bypass queue and speak immediately
|
|
self.clear_queue()
|
|
self._message_queue.put(text)
|
|
logging.debug("Force speaking immediately: {}".format(text))
|
|
else:
|
|
self._message_queue.put(text)
|
|
|
|
def clear_queue(self):
|
|
"""
|
|
Safely drains all pending messages from the queue.
|
|
"""
|
|
logging.info("Message queue size: {}".format(self._message_queue.qsize()))
|
|
try:
|
|
while True:
|
|
# Remove items one by one without waiting
|
|
self._message_queue.get_nowait()
|
|
except Queue.Empty:
|
|
pass
|
|
logging.info("Message queue cleared.")
|
|
|
|
def _handle_gesture(self, message, is_single):
|
|
"""
|
|
Handle a gesture actuation request.
|
|
|
|
:param message: The gesture to do, must contain properties "endpoint" and "data".
|
|
:type message: dict
|
|
|
|
:param is_single: Whether it's a specific single gesture or a gesture tag.
|
|
:type is_single: bool
|
|
"""
|
|
|
|
gesture = message.get("data")
|
|
if not gesture:
|
|
logging.warn("Received gesture to do, but it lacks data.")
|
|
return
|
|
|
|
if not isinstance(gesture, (str, unicode)):
|
|
logging.warn("Received gesture to do but it is not a string.")
|
|
return
|
|
|
|
logging.debug("Received gesture to do: {}".format(gesture))
|
|
|
|
if is_single:
|
|
if gesture not in GestureTags.single_gestures:
|
|
logging.warn("Received single gesture to do, but it does not exist in settings")
|
|
return
|
|
else:
|
|
if gesture not in GestureTags.tags:
|
|
logging.warn("Received single tag to do, but it does not exist in settings")
|
|
return
|
|
|
|
if not state.qi_session: return
|
|
# If state has a qi_session, we know that we can import qi
|
|
import qi # Takes a while only the first time it's imported
|
|
|
|
if not self._animation_service:
|
|
self._animation_service = state.qi_session.service("ALAnimationPlayer")
|
|
|
|
# Play the gesture. Pepper comes with predefined animations like "Wave", "Greet", "Clap"
|
|
# You can also create custom animations using Choregraphe and upload them to the robot.
|
|
if is_single:
|
|
logging.debug("Playing single gesture: {}".format(gesture))
|
|
getattr(qi, "async")(self._animation_service.run, gesture)
|
|
else:
|
|
logging.debug("Playing tag gesture: {}".format(gesture))
|
|
getattr(qi, "async")(self._animation_service.runTag, gesture)
|
|
|
|
def handle_message(self, message):
|
|
"""
|
|
Handle an actuation/speech message with the receiver.
|
|
|
|
:param message: The message to handle, must contain properties "endpoint" and "data".
|
|
:type message: dict
|
|
"""
|
|
if message["endpoint"] == "actuate/speech":
|
|
self._handle_speech(message)
|
|
if message["endpoint"] == "actuate/gesture/tag":
|
|
self._handle_gesture(message, False)
|
|
if message["endpoint"] == "actuate/gesture/single":
|
|
self._handle_gesture(message, True)
|
|
|
|
def _handle_messages(self):
|
|
while not state.exit_event.is_set():
|
|
try:
|
|
text = self._message_queue.get(timeout=0.1)
|
|
state.is_speaking = True
|
|
self._tts_service.say(text)
|
|
except Queue.Empty:
|
|
state.is_speaking = False
|
|
except RuntimeError:
|
|
logging.error("Lost connection to Pepper. Please check if you're connected to the "
|
|
"local WiFi and restart this application.")
|
|
state.exit_event.set()
|
|
|
|
def endpoint_description(self):
|
|
"""
|
|
Extend the default endpoint description with gesture tags.
|
|
Returned during negotiate/ports so the CB knows available gestures.
|
|
"""
|
|
desc = super(ActuationReceiver, self).endpoint_description()
|
|
desc["gestures"] = GestureTags.tags
|
|
desc["single_gestures"] = GestureTags.single_gestures
|
|
return desc
|