rospeex_spi.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 os
import sys
import rospy
import rospkg
import datetime
import platform

# Import ROS messages
from rospeex_msgs.msg import SignalProcessingResponse
from rospeex_msgs.msg import SpeechSynthesisState

# Import other libraries
from rospeex_core.spi import ConnectorInterface
from rospeex_core.spi import WebAudioMonitor
from rospeex_core.exceptions import SignalProcessingInterfaceException
from rospeex_core.exceptions import WebAudioMonitorException


class SignalProcessingInterface(object):
    """ SignalProcessingInterface class """

    _SPI_RESPONSE_TOPIC_NAME = 'spi_res'
    _SS_STATE_TOPIC_NAME = 'ss_state'

    def __init__(self):
        """ init function """
        package = rospkg.RosPack()
        rospeex_dir = package.get_path('rospeex_core')
        self._connector = None
        self._ip_addr = '127.0.0.1'
        self._app_dir = os.path.join(rospeex_dir, 'bin')
        self._controller = 'NICTmmcvController'
        self._webmonitor = 'monitorServer.nex'
        self._nict_mmcv = 'NICTmmcv'
        self._mmse_setting = 'NICTmmcv.mmse.ini'
        self._vad_setting = 'NICTmmcv.vad.ini'
        self._audio_dir = 'tmp'
        self._recv_port = 5002
        self._send_port = 16001
        self._websocket_port = 9000
        self._request_id = 0
        self._log_level = 'warn'
        self._audio_monitor_type = 'qt'
        self._audio_monitor = None
        self._pub_spi = None

    def _ss_state_response(self, response):
        """ receive speech synthesis node state
        @param response: response data
        @type  response: str
        """
        rospy.loginfo(response)
        self._connector.set_play_sound_state(response.play_state)

    def _ui_response(self, data):
        """ receive user interface response
        @param data: voice data
        @type  data: str
        """
        msg = SignalProcessingResponse()
        msg.header.user = rospy.get_name()
        msg.header.request_id = str(self._request_id)
        msg.data = data
        self._pub_spi.publish(msg)
        self._request_id += 1

        now = datetime.datetime.now().strftime('%Y%m%d%H%M%S')
        filename = '%s.wav' % now
        filepath = os.path.join(self._audio_dir, filename)
        with open(filepath, 'wb') as wavefile:
            wavefile.write(data)

    def _update_connection_parameter(self):
        """ update connection parameter """
        self._ip_addr = rospy.get_param('~ip_addr', self._ip_addr)
        self._recv_port = rospy.get_param('~recv_port', self._recv_port)
        self._send_port = rospy.get_param('~send_port', self._send_port)
        self._log_level = rospy.get_param('~log_level', self._log_level)
        self._websocket_port = rospy.get_param('~websocket_port', self._websocket_port)
        self._audio_monitor_type = rospy.get_param('~audio_monitor', self._audio_monitor_type)
        self._audio_dir = rospy.get_param('~audio_dir', self._audio_dir)
        self._audio_monitor = None

        # show parameter list
        rospy.loginfo('parameter:\n'\
                      'tip_addr       :%s\n'\
                      '  \trecv_port     :%s\n'\
                      '  \tsend_port     :%s\n'\
                      '  \taudio_monitor :%s\n'\
                      '  \twebsocket_port:%s'\
                       %(self._ip_addr,\
                        self._recv_port,\
                        self._send_port,\
                        self._audio_monitor_type,\
                        self._websocket_port))

    def _update_application_dir(self):
        """ update application directory. (32bit or 64bit) """
        arch = platform.architecture()
        try:
            if arch[0] == '32bit':
                self._app_dir = os.path.join(self._app_dir, 'x86')
            else:
                self._app_dir = os.path.join(self._app_dir, 'x64')
        except IndexError as err:
            rospy.info('platform.architecture() returns unexcepted value. Value: %s', str(arch))
            self._app_dir = os.path.join(self._app_dir, 'x64')

    def shutdown(self):
        """ shutdown speech processing interface """
        if self._connector:
            self._connector.shutdown()

        if self._audio_monitor:
            self._audio_monitor.exit()

    def run(self):
        """ run application """
        rospy.init_node('rospeex_spi')

        # create publisher / sucscriber
        self._pub_spi = rospy.Publisher(self._SPI_RESPONSE_TOPIC_NAME, SignalProcessingResponse)
        rospy.Subscriber(self._SS_STATE_TOPIC_NAME, SpeechSynthesisState, self._ss_state_response)

        # update parameters
        self._update_connection_parameter()

        # update application directory
        self._update_application_dir()

        # create path
        if not os.path.exists(self._audio_dir):
            os.makedirs(self._audio_dir)

        # create connection
        self._connector = ConnectorInterface(
            app_dir=self._app_dir,
            controller=self._controller,
            nict_mmcv=self._nict_mmcv,
            mmse_setting=self._mmse_setting,
            vad_setting=self._vad_setting,
            ip_addr=self._ip_addr,
            recv_port=self._recv_port,
            send_port=self._send_port,
            log_level=self._log_level
        )

        self._connector.register_callback(self._ui_response)
        self._connector.start()

        # start audio web audio monitor
        if self._audio_monitor_type == 'web':
            self._audio_monitor = WebAudioMonitor(
                app_dir=self._app_dir,
                app_name=self._webmonitor,
                send_port=self._send_port,
                recv_port=self._recv_port,
                websocket_port=self._websocket_port
            )
            self._audio_monitor.launch()

        # main loop
        rospy.loginfo('start signal processing interface node.')
        rate = rospy.Rate(100)
        while not rospy.is_shutdown():
            if self._audio_monitor:
                if not self._audio_monitor.is_alive():
                    self._audio_monitor.exit()
                    raise WebAudioMonitorException('WebAudioMonitor is terminated.')
            rate.sleep()


def main():
    """ mian function """
    spi_node = None

    try:
        spi_node = SignalProcessingInterface()
        spi_node.run()

    except SignalProcessingInterfaceException as err:
        rospy.logfatal(str(err))

    except rospy.ROSInterruptException as err:
        rospy.loginfo(str(err))

    except WebAudioMonitorException as err:
        rospy.logfatal(str(err))

    except Exception as err:
        rospy.logfatal(str(err))

    finally:
        if spi_node is not None:
            spi_node.shutdown()
    return 0


if __name__ == '__main__':
    sys.exit(main())