Statistics
| Branch: | Tag: | Revision:

hlrc / client / python / hlrc_client / RobotController.py @ c00b9328

History | View | Annotate | Download (5.845 KB)

1
"""
2
This file is part of hlrc
3

4
Copyright(c) sschulz <AT> techfak.uni-bielefeld.de
5
http://opensource.cit-ec.de/projects/hlrc
6

7
This file may be licensed under the terms of the
8
GNU General Public License Version 3 (the ``GPL''),
9
or (at your option) any later version.
10

11
Software distributed under the License is distributed
12
on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
13
express or implied. See the GPL for the specific language
14
governing rights and limitations.
15

16
You should have received a copy of the GPL along with this
17
program. If not, go to http://www.gnu.org/licenses/gpl.html
18
or write to the Free Software Foundation, Inc.,
19
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20

21
The development of this software was supported by the
22
Excellence Cluster EXC 277 Cognitive Interaction Technology.
23
The Excellence Cluster EXC 277 is a grant of the Deutsche
24
Forschungsgemeinschaft (DFG) in the context of the German
25
Excellence Initiative.
26
"""
27

    
28
import logging
29
import sys
30
import errno
31

    
32
class RobotController:
33
    def __init__(self, mw_name, scope, loglevel=logging.WARNING):
34
        """initialise
35
        :param mw_name: which mw to use, currentyl ROS and RSB are supported
36
        :param scope: base scope we want to listen on
37
        :param  loglevel: optional log level
38
        """
39
        self.logger = logging.getLogger(__name__)
40

    
41
        # create nice and actually usable formatter and add it to the handler
42
        self.config_logger(loglevel)
43

    
44
        #store
45
        self.scope = scope
46
        self.mw = mw_name
47
        self.loglevel = loglevel
48

    
49
        self.middleware = None
50

    
51

    
52
        if (self.mw.upper() == "RSB"):
53
            self.logger.info("creating new middleware connection via RSB")
54
            try:
55
                from MiddlewareRSB import MiddlewareRSB
56
            except ImportError, e:
57
                self.logger.error("failed to import RSB or the necessary data types: {}".format(e))
58
                sys.exit(errno.EINVAL)
59

    
60
            #import worked, safe to intantiate RSB mw now
61
            self.middleware = MiddlewareRSB(self.scope, self.loglevel)
62

    
63
        elif (self.mw.upper() == "ROS"):
64
            self.logger.info("creating new middleware connection via ROS")
65
            try:
66
                from MiddlewareROS import MiddlewareROS
67
            except ImportError, e:
68
                self.logger.error("failed to import ROS or the necessary data types: {}".format(e))
69
                sys.exit(errno.EINVAL)
70

    
71
            #import worked, safe to intantiate RSB mw now
72
            self.middleware = MiddlewareROS(self.scope, self.loglevel)
73
        else:
74
            self.logger.error("invalid middleware requested (%s). supported: {ROS, RSB}\n\n" % (self.mw))
75
            sys.exit(errno.EINVAL)
76

    
77
    def __del__(self):
78
        """destructor
79
        """
80
        self.logger.debug("destructor of RobotController called")
81

    
82
    def is_running(self):
83
        return self.middleware.is_running()
84

    
85
    def config_logger(self, level):
86
        """initialise a nice logger formatting
87
        :param  level: log level
88
        """
89
        formatter = logging.Formatter('%(asctime)s %(name)-30s %(levelname)-8s > %(message)s')
90
        ch = logging.StreamHandler()
91
        #ch.setLevel(level)
92
        ch.setFormatter(formatter)
93
        self.logger.setLevel(level)
94
        self.logger.addHandler(ch)
95

    
96
    def set_current_emotion(self, robot_emotion, blocking = False):
97
        """set the current emotion
98
        :param robot_emotion: a RobotEmotion object
99
        :param blocking: should this call block during execution?
100
        """
101
        self.logger.debug("set_current_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))
102
        self.middleware.set_current_emotion(robot_emotion, blocking)
103

    
104
    def set_default_emotion(self, robot_emotion, blocking = False):
105
        """set the default emotion
106
        :param robot_emotion: a RobotEmotion object
107
        :param blocking: should this call block during execution?
108
        """
109
        self.logger.debug("set_default_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))
110
        self.middleware.set_default_emotion(robot_emotion, blocking)
111

    
112
    def set_gaze_target(self, robot_gaze, blocking = False):
113
        """set a gaze target
114
        :param robot_gaze: a RobotGaze object
115
        :param blocking: should this call block during execution?
116
        """
117

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

    
121
    def set_mouth_target(self, robot_mouth, blocking = False):
122
        """set a mouth target
123
        :param robot_mouth: a RobotMouth object
124
        :param blocking: should this call block during execution?
125
        """
126
        self.logger.debug("set_mouth_target(%s) %s" % (robot_mouth, ("BLOCKING" if blocking else "NON_BLOCKING")))
127
        self.middleware.set_mouth_target(robot_mouth, blocking)
128

    
129
    def set_head_animation(self, robot_animation, blocking = False):
130
        """set a head animation
131
        :param robot_animation: a RobotAnimation object
132
        :param blocking: should this call block during execution?
133
        """
134
        self.logger.debug("set_head_animation(%s) %s" % (robot_animation, ("BLOCKING" if blocking else "NON_BLOCKING")))
135
        self.middleware.set_head_animation(robot_animation, blocking)
136

    
137
    def set_speak(self, text, blocking = False):
138
        """request the robot to say something using tts
139
        :param text: text to synthesize
140
        :param blocking: should this call block during execution?
141
        """
142
        self.logger.debug("set_speak(%s) %s" % (text, ("BLOCKING" if blocking else "NON_BLOCKING")))
143
        self.middleware.set_speak(text, blocking)
144

    
145
    #def get_gaze_target(self):
146
    #       result = self.middleware.get_gaze_target()
147
    #       self.logger.debug("get_gaze_target() returned %s" % (result))
148
    #       return self.middleware.get_gaze_target()