Statistics
| Branch: | Tag: | Revision:

hlrc / client / python / hlrc_client / RobotController.py @ 013997fb

History | View | Annotate | Download (5.251 KB)

1 0c286af0 Simon Schulz
"""
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 ba6302b1 Simon Schulz
import sys
30 64f5c90e Simon Schulz
import errno
31 0c286af0 Simon Schulz
32
class RobotController:
33
        def __init__(self, mw_name, scope, loglevel=logging.WARNING):
34 f8fa1217 Simon Schulz
                """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 0c286af0 Simon Schulz
                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 f8fa1217 Simon Schulz
                #store 
45 0c286af0 Simon Schulz
                self.scope = scope
46 f8fa1217 Simon Schulz
                self.mw = mw_name
47
                self.loglevel = loglevel
48 0c286af0 Simon Schulz
                
49 f8fa1217 Simon Schulz
                self.middleware = None
50
                
51
                                
52
                if (self.mw.upper() == "RSB"):
53 64f5c90e Simon Schulz
                        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 ba6302b1 Simon Schulz
                                sys.exit(errno.EINVAL)
59 64f5c90e Simon Schulz
60
                        #import worked, safe to intantiate RSB mw now
61
                        self.middleware = MiddlewareRSB(self.scope, self.loglevel)
62
63 f8fa1217 Simon Schulz
                elif (self.mw.upper() == "ROS"):
64 0c286af0 Simon Schulz
                        self.logger.info("creating new middleware connection via ROS")
65 64f5c90e Simon Schulz
                        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 f8fa1217 Simon Schulz
                        self.middleware = MiddlewareROS(self.scope, self.loglevel)
73 0c286af0 Simon Schulz
                else:
74 f8fa1217 Simon Schulz
                        self.logger.error("invalid middleware requested (%s). supported: {ROS, RSB}\n\n" % (self.mw))
75 0c286af0 Simon Schulz
                        sys.exit(errno.EINVAL)
76
        
77 f8fa1217 Simon Schulz
        def __del__(self):
78
                """destructor
79
                """
80
                self.logger.debug("destructor of RobotController called")
81
        
82 0c286af0 Simon Schulz
        def config_logger(self, level):
83 f8fa1217 Simon Schulz
                """initialise a nice logger formatting
84
                :param  level: log level
85
                """
86 0c286af0 Simon Schulz
                formatter = logging.Formatter('%(asctime)s %(name)-30s %(levelname)-8s > %(message)s')
87
                ch = logging.StreamHandler()
88
                #ch.setLevel(level)
89
                ch.setFormatter(formatter)
90
                self.logger.setLevel(level)
91
                self.logger.addHandler(ch)
92
93
        def set_current_emotion(self, robot_emotion, blocking = False):
94 f8fa1217 Simon Schulz
                """set the current emotion
95
                :param robot_emotion: a RobotEmotion object
96
                :param blocking: should this call block during execution?
97
                """
98 0c286af0 Simon Schulz
                self.logger.debug("set_current_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))
99
                self.middleware.set_current_emotion(robot_emotion, blocking)
100
                
101
        def set_default_emotion(self, robot_emotion, blocking = False):
102 f8fa1217 Simon Schulz
                """set the default emotion
103
                :param robot_emotion: a RobotEmotion object
104
                :param blocking: should this call block during execution?
105
                """
106 0c286af0 Simon Schulz
                self.logger.debug("set_default_emotion(%s) %s" % (robot_emotion, ("BLOCKING" if blocking else "NON_BLOCKING")))
107
                self.middleware.set_default_emotion(robot_emotion, blocking)
108
        
109
        def set_gaze_target(self, robot_gaze, blocking = False):
110 f8fa1217 Simon Schulz
                """set a gaze target
111
                :param robot_gaze: a RobotGaze object
112
                :param blocking: should this call block during execution?
113
                """
114
                
115 0c286af0 Simon Schulz
                self.logger.debug("set_gaze_target(%s) %s" % (robot_gaze, ("BLOCKING" if blocking else "NON_BLOCKING")))
116
                self.middleware.set_gaze_target(robot_gaze, blocking)
117
        
118
        def set_mouth_target(self, robot_mouth, blocking = False):
119 f8fa1217 Simon Schulz
                """set a mouth target
120
                :param robot_mouth: a RobotMouth object
121
                :param blocking: should this call block during execution?
122
                """                
123 0c286af0 Simon Schulz
                self.logger.debug("set_mouth_target(%s) %s" % (robot_mouth, ("BLOCKING" if blocking else "NON_BLOCKING")))
124
                self.middleware.set_mouth_target(robot_mouth, blocking)
125
        
126
        def set_head_animation(self, robot_animation, blocking = False):
127 f8fa1217 Simon Schulz
                """set a head animation
128
                :param robot_animation: a RobotAnimation object
129
                :param blocking: should this call block during execution?
130
                """                
131 0c286af0 Simon Schulz
                self.logger.debug("set_head_animation(%s) %s" % (robot_animation, ("BLOCKING" if blocking else "NON_BLOCKING")))
132
                self.middleware.set_head_animation(robot_animation, blocking)
133
        
134
        def set_speak(self, text, blocking = False):
135 f8fa1217 Simon Schulz
                """request the robot to say something using tts
136
                :param text: text to synthesize
137
                :param blocking: should this call block during execution?
138
                """
139 0c286af0 Simon Schulz
                self.logger.debug("set_speak(%s) %s" % (text, ("BLOCKING" if blocking else "NON_BLOCKING")))
140
                self.middleware.set_speak(text, blocking)
141
142 f8fa1217 Simon Schulz
        #def get_gaze_target(self):
143
        #        result = self.middleware.get_gaze_target()
144
        #        self.logger.debug("get_gaze_target() returned %s" % (result))
145
        #        return self.middleware.get_gaze_target()