rospeex_sr.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Import ROS packages
try:
    import roslib; roslib.load_manifest('rospeex_core')
except:
    pass

import rospy
import traceback

# Import Messages
from rospeex_msgs.msg import SpeechRecognitionResponse
from rospeex_msgs.msg import SpeechRecognitionRequest

# Import speech synthesis client
from rospeex_core.sr import SpeechRecognitionFactory
from rospeex_core.exceptions import SpeechRecognitionException
from rospeex_core.exceptions import ParameterException
from rospeex_core.exceptions import ServerException

class SpeechRecognition(object):
    """ SpeechRecognition class """

    _MY_NODE_NAME = 'rospeex_sr'
    _REQUEST_TOPIC_NAME = 'sr_req'
    _RESPONSE_TOPIC_NAME = 'sr_res'

    def __init__(self):
        """ init """
        self._publisher = None
        self._user_request_dict = {}

    def _update_user_dictionary(self, header):
        """ renew user request dictionary
        @param header: request header
        @type  header: str
        """
        if self._user_request_dict.has_key(header.user):
            self._user_request_dict[header.user] += 1
            if int(header.request_id) != self._user_request_dict[header.user]:
                # check request id
                rospy.logwarn('invalid request id. user:%s  \
                               current id:%d  \
                               previous id:%d'\
                               %(header.user, \
                                int(header.request_id), \
                                self._user_request_dict[header.user]))
            # update request id
            self._user_request_dict[header.user] = int(header.request_id)
        else:
            self._user_request_dict.update({header.user:int(header.request_id)})
            rospy.logdebug('add new user:%s' % header.user)


    def _callback_func(self, request):
        """ callback function for sr_req topic
        @param request: topic data
        @type  request: str
        """
        rospy.loginfo(request)
        response = SpeechRecognitionResponse()
        response.header = request.header

        # update user dictionary
        self._update_user_dictionary(request.header)

        # Create speeech synthesis client
        try:
            # execute speech synthtesis
            client = SpeechRecognitionFactory().create(engine=request.header.engine)
            response.message = client.request(request.data, request.header.language)
        except SpeechRecognitionException as err:
            rospy.logerr('[SpeechRecognitionException] ' + str(err))
            response.memo = str(err)
        except ParameterException as err:
            rospy.logerr('[ParameterException] ' + str(err))
            response.memo = str(err)
        except ServerException as err:
            rospy.logerr('[ServerException] ' + str(err))
            response.memo = str(err)

        # send speech synthesis response to subscribe node
        # sr result contains NOT ascii format.
        rospy.loginfo(response.header)
        self._publisher.publish(response)


    def run(self):
        """ run rospeex sr node """
        rospy.init_node(self._MY_NODE_NAME)
        rospy.Subscriber(self._REQUEST_TOPIC_NAME, SpeechRecognitionRequest, self._callback_func)
        self._publisher = rospy.Publisher(self._RESPONSE_TOPIC_NAME, SpeechRecognitionResponse)
        rospy.loginfo("start speech recognition node")
        rospy.spin()


if __name__ == '__main__':
    try:
        node = SpeechRecognition()
        node.run()
    except rospy.ROSInterruptException:
        pass
    except Exception:
        rospy.logfatal(traceback.format_exc())