hlrc

"""

This file is part of hlrc

Copyright(c) sschulz <AT> techfak.uni-bielefeld.de

http://opensource.cit-ec.de/projects/hlrc

This file may be licensed under the terms of the

GNU General Public License Version 3 (the ``GPL''),

or (at your option) any later version.

Software distributed under the License is distributed

on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either

express or implied. See the GPL for the specific language

governing rights and limitations.

You should have received a copy of the GPL along with this

program. If not, go to http://www.gnu.org/licenses/gpl.html

or write to the Free Software Foundation, Inc.,

51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

The development of this software was supported by the

Excellence Cluster EXC 277 Cognitive Interaction Technology.

The Excellence Cluster EXC 277 is a grant of the Deutsche

Forschungsgemeinschaft (DFG) in the context of the German

Excellence Initiative.

"""

import logging

import sys

import errno

class RobotController:

    def __init__(self, mw_name, scope, loglevel=logging.WARNING, timeout=None):

        """initialise

        :param mw_name: which mw to use, currentyl ROS and RSB are supported

        :param scope: base scope we want to listen on

        :param  loglevel: optional log level

        """

        self.logger = logging.getLogger(__name__)

        # create nice and actually usable formatter and add it to the handler

        self.config_logger(loglevel)

        # store

        self.scope = scope

        self.mw = mw_name

        self.loglevel = loglevel

        self.middleware = None

        if (self.mw.upper() == "RSB"):

            self.logger.info("creating new middleware connection via RSB")

            try:

                from MiddlewareRSB import MiddlewareRSB

            except ImportError, e:

                self.logger.error("failed to import RSB or the necessary data types: {}".format(e))

                sys.exit(errno.EINVAL)

            # import worked, safe to intantiate RSB mw now

            self.middleware = MiddlewareRSB(self.scope, self.loglevel)

        elif (self.mw.upper() == "ROS"):

            self.logger.info("creating new middleware connection via ROS")

            try:

                from MiddlewareROS import MiddlewareROS

            except ImportError, e:

                self.logger.error("failed to import ROS or the necessary data types: {}".format(e))

                sys.exit(errno.EINVAL)

            # import worked, safe to instantiate RSB mw now

            self.middleware = MiddlewareROS(self.scope, self.loglevel, timeout)

        else:

            self.logger.error("invalid middleware requested (%s). supported: {ROS, RSB}\n\n" % (self.mw))

            sys.exit(errno.EINVAL)

    def __del__(self):

        """destructor

        """

        try: # if constructor failed, logger attribute might be missing

            self.logger.debug("destructor of RobotController called")

        except AttributeError:

            pass

    def is_running(self):

        return self.middleware.is_running()

    def config_logger(self, level):

        """initialise a nice logger formatting

        :param  level: log level

        """

        formatter = logging.Formatter('%(asctime)s %(name)-30s %(levelname)-8s > %(message)s')

        ch = logging.StreamHandler()

        # ch.setLevel(level)

        ch.setFormatter(formatter)

        self.logger.setLevel(level)

        self.logger.addHandler(ch)

    def set_current_emotion(self, robot_emotion, blocking=False):

        """set the current emotion

        :param robot_emotion: a RobotEmotion object

        :param blocking: should this call block during execution?

        """

        self.logger.debug("set_current_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))

        self.middleware.set_current_emotion(robot_emotion, blocking)

    def set_default_emotion(self, robot_emotion, blocking=False):

        """set the default emotion

        :param robot_emotion: a RobotEmotion object

        :param blocking: should this call block during execution?

        """

        self.logger.debug("set_default_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))

        self.middleware.set_default_emotion(robot_emotion, blocking)

    def set_gaze_target(self, robot_gaze, blocking=False):

        """set a gaze target

        :param robot_gaze: a RobotGaze object

        :param blocking: should this call block during execution?

        """

        self.logger.debug("set_gaze_target(%s) %s" % (robot_gaze, ("BLOCKING" if blocking else "NON_BLOCKING")))

        self.middleware.set_gaze_target(robot_gaze, blocking)

    def set_lookat_target(self, x, y, z, blocking=False, frame_id='', roll=0.0):

        """set a gaze at a Cartesian position

        :param x,y,z: position to look at (in eyes frame or frame_id)

        :param roll: side-ways motion of head

        :param blocking: True if this call should block until execution finished on robot

        """

        self.logger.debug("set_lookat_target(%s) %s" % ((x,y,z), "BLOCKING" if blocking else "NON_BLOCKING"))

        self.middleware.set_lookat_target(x, y, z, blocking, frame_id, roll)

    def set_mouth_target(self, robot_mouth, blocking=False):

        """set a mouth target

        :param robot_mouth: a RobotMouth object

        :param blocking: should this call block during execution?

        """

        self.logger.debug("set_mouth_target(%s) %s" % (robot_mouth, ("BLOCKING" if blocking else "NON_BLOCKING")))

        self.middleware.set_mouth_target(robot_mouth, blocking)

    def set_head_animation(self, robot_animation, blocking=False):

        """set a head animation

        :param robot_animation: a RobotAnimation object

        :param blocking: should this call block during execution?

        """

        self.logger.debug("set_head_animation(%s) %s" % (robot_animation, ("BLOCKING" if blocking else "NON_BLOCKING")))

        self.middleware.set_head_animation(robot_animation, blocking)

    def set_speak(self, text, blocking=False):

        """request the robot to say something using tts

        :param text: text to synthesize

        :param blocking: should this call block during execution?

        """

        self.logger.debug("set_speak(%s) %s" % (text, ("BLOCKING" if blocking else "NON_BLOCKING")))

        self.middleware.set_speak(text, blocking)