hlrc

        #init base settings

        Middleware.__init__(self,scope,loglevel)

        #mute rsb logging:

        self.logger.info("initialising RSB middleware connection on scope %s, registering rst converters..." % (self.base_scope))

        self.EmotionExpression_converter = rsb.converter.ProtocolBufferConverter(messageClass = EmotionExpression)

        self.HeadAnimation_converter = rsb.converter.ProtocolBufferConverter(messageClass = HeadAnimation)

        self.BinocularHeadGaze_converter = rsb.converter.ProtocolBufferConverter(messageClass = BinocularHeadGaze)

        #create emotion & fill it with values:

                #we could block here for a incoming result with a timeout in s

                #print '> server reply: "%s"' % future.get(timeout = 10);

        #create HeadAnimation & fill it with values:

        rsb_ani.scale       = HeadAnimation.scale

        #create gaze target & fill it with values:

	    rsb_gaze.target = SphericalDirectionFloat()

	    rsb_gaze.target.elevation = gaze.tilt

	    rsb_gaze.target.azimuth   = gaze.pan

	    rsb_gaze.offset = SphericalDirectionFloat()

	    rsb_gaze.offset.elevation = gaze.tilt_offset

	    rsb_gaze.offset.azimuth   = gaze.pan_offset

            #blocking:

            #we can block here for a incoming result with a timeout in s

    """

    def publish_mouth_target(self, mouth, blocking):

        publish a mouth target via mw

        :param mouth: mouth value to set

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

        self.logger.debug("calling the mouth rpc (%s)..." % ("BLOCKING" if blocking else "NON-BLOCKING"))

        #create mouth state & fill it with values:

        rsb_mouth = MouthTarget()

        #fill proto

        rsb_mouth.opening_left   = mouth.opening_left

        rsb_mouth.opening_center = mouth.opening_center

        rsb_mouth.opening_right  = mouth.opening_right

        rsb_mouth.position_left  = mouth.position_left

        rsb_mouth.position_center = mouth.position_center

        rsb_mouth.position_right = mouth.position_right

        if (blocking):

            #blocking:

            result = self.server.mouth(rsb_mouth)

            self.logger.debug("server reply: '%s'" % result)

        else:

            future = self.server.mouth.async(rsb_mouth)

            #we can block here for a incoming result with a timeout in s

            #print '> server reply: "%s"' % future.get(timeout = 10);

        self.logger.debug("mouth rpc done")

    def publish_speech(self, text, blocking):

        """publish a tts request via mw

        :param text: text to synthesize and speak

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

        """

        self.logger.debug("calling the speech rpc (%s)..." % ("BLOCKING" if blocking else "NON-BLOCKING"))

        if (blocking):

            #blocking:

            result = self.server.speech(text)

            self.logger.debug("server reply: '%s'" % result)

        else:

            future = self.server.speech.async(text)

            #we can block here for a incoming result with a timeout in s

            #print '> server reply: "%s"' % future.get(timeout = 10);

        self.logger.debug("speech rpc done")

    #######################################################################

    def is_running(self):

        return True

    #######################################################################

    # some helpers

    def convert_HeadAnimationtype_to_rsbval(self, value):

        """convert RobotHeadAnimation.value to RSB HeadAnimation value

        :param value: RobotHeadAnimation.* id to convert to rsb id

        """

        #NOTE: this convertion is important as the actual integer values of

        #      thy python api and the protobuf might be different

        if (value == RobotHeadAnimation.IDLE):

            return HeadAnimation().IDLE

        elif (value == RobotHeadAnimation.HEAD_NOD):

            return HeadAnimation().HEAD_NOD

        elif (value == RobotHeadAnimation.HEAD_SHAKE):

            return HeadAnimation().HEAD_SHAKE

        elif (value == RobotHeadAnimation.EYEBLINK_L):

            return HeadAnimation().EYEBLINK_L

        elif (value == RobotHeadAnimation.EYEBLINK_R):

            return  HeadAnimation().EYEBLINK_R

        elif (value == RobotHeadAnimation.EYEBLINK_BOTH):

            return  HeadAnimation().EYEBLINK_BOTH

        elif (value == RobotHeadAnimation.EYEBROWS_RAISE):

            return  HeadAnimation().EYEBROWS_RAISE

        elif (value == RobotHeadAnimation.EYEBROWS_LOWER):

            return  HeadAnimation().EYEBROWS_LOWER

        else:

            self.logger.error("invalid HeadAnimation type %d\n" % (value))

            return  HeadAnimation().NEUTRAL

    def convert_emotiontype_to_rsbval(self, value):

        """convert RobotEmotion.value to RSB HeadAnimation value

        :param value: RobotEmotion.* id to convert to rsb id

        """

        #NOTE: this convertion is important as the actual integer values of

        #      thy python api and the protobuf might be different

        if (value == RobotEmotion.NEUTRAL):

            return EmotionExpression().NEUTRAL

        elif (value == RobotEmotion.HAPPY):

            return EmotionExpression().HAPPY

        elif (value == RobotEmotion.SAD):

            return EmotionExpression().SAD

        elif (value == RobotEmotion.ANGRY):

            return EmotionExpression().ANGRY

        elif (value == RobotEmotion.SURPRISED):

            return  EmotionExpression().SURPRISED

        elif (value == RobotEmotion.FEAR):

            return EmotionExpression().FEAR

        else:

            self.logger.error("invalid emotion type %d\n" % (value))

            return  EmotionExpression().NEUTRAL