Python String.data方法代码示例

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
    def execute(self, ud):

        tts_msg = String()
        tts_msg.data = 'Do you want me to start guiding you back to the arena?'
        self.tts_pub.publish(tts_msg)

        self.question_asked = True

        return_param = ''

        while True:
            self.mutex.acquire()
            if self.confirmation_received:
                if self.start_guiding:
                    tts_msg.data = "I will guide you back to the arena."
                    self.tts_pub.publish(tts_msg)
                    try:
                        self.people_follower_srv.call(request=peopleFollowerRequest.RELEASE_TARGET)
                    except rospy.ServiceException:
                        pass
                    return_param = 'start_guiding'
                else:
                    return_param = 'do_not_guide'

                self.mutex.release()
                break
            self.mutex.release()

        return return_param

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
  def run(self):
    self.speechRecogProxy.setLanguage("English")
    wordList = ["come", "go", "stand", "sit", "relax", "stiffen"]
    self.speechRecogProxy.setWordListAsVocabulary(wordList)
    self.speechRecogProxy.subscribe("ros")

    self.dataNamesList = ["WordRecognized"]
    
    self.recognizedWordPub = rospy.Publisher("recognized_word", String)   
    self.textToSpeechPub   = rospy.Publisher("speech", String)

    r = rospy.Rate(5)
    prev_word = str()
    while not rospy.is_shutdown():
      try:
        memoryData = self.memoryProxy.getListData(self.dataNamesList)
      except RuntimeError,e:
        rospy.logerr("Error accessing ALMemory: %s", e)
        rospy.signal_shutdown("No NaoQI available anymore")

      if (memoryData[0][1] >= 0.2) and (memoryData[0][0] != prev_word):
        msg = String()
        msg.data = memoryData[0][0]
        self.recognizedWordPub.publish(msg)
        msg = String()
        msg.data = "Oh kay."
        self.textToSpeechPub.publish(msg)
        prev_word = memoryData[0][0]

      # reset  
      if memoryData[0][0] == '':
        prev_word = ''

      r.sleep()

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
def property_changed(interface, changed, invalidated, path):
        iface = interface[interface.rfind(".") + 1:]
        for name, value in changed.iteritems():
                val = str(value)
                #print(name + "=" + val)
                if name == 'Connected':
                        if val == "1":
                                print("ON")
                                message = String()
                                message.data = "gpio,w,on"
                                send(message)
                        elif val == "0":
                                print("OFF")
                                message = String()
                                message.data = "gpio,w,off"
                                send(message)
                                advertise()

                        else:
                                pass
                elif name == 'Alias' or name == 'Name':
                    print("ON")
                    message = String()
                    message.data = "gpio,w,on"
                    send(message)
                else:
                        pass

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
    def decision_function(self):
        last_three = self.engagement_history[-3:]
        mean = sum(last_three)/3
        
        # Let at least do 3 trials in 5 min with a bad mean
        #if mean < 10 and self.current_time > 300 and np.size(self.engagement_history) > 3:
#        if self.current_time > 36000000:
#            self.engagement_history = self.engagement_history[0:-3]
#            msg = String()
#            if self.activity_turn:
#                msg.data = "drawing_nao"
#                #self.activity_turn = False
#            else:
#                pass
#                #msg.data = "joke_nao"
#                #self.activity_turn = True
#            self.pub_activity.publish(msg)
        
        msg = String()
        if self.nb_repetitions == 14:
            msg.data = "drawing_nao"
            #self.activity_turn = False
            self.pub_activity.publish(msg)
        if self.nb_repetitions == 7:
            msg.data = "drawing_nao"
            #self.activity_turn = False
            self.pub_activity.publish(msg)

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
    def execute(self, userdata):

        #self.ON_pub.publish(Empty())
        rospy.sleep(120)

	my_string=String()
	my_string.data="Il est l'heure de se lever. Debout les feignants."
	self.french_pub.publish(my_string)

        rospy.sleep(480)
	self.ON2_pub.publish(Empty())

        rospy.sleep(120)
	my_string.data="Chauffage de la salle de bain en cours."
	self.french_pub.publish(my_string)
        rospy.sleep(0.01)
	self.heatON_pub.publish(Empty())
        rospy.sleep(0.01)
	self.music_pub.publish(Empty())

        rospy.sleep(60)
	self.weather_pub.publish(Empty())

        rospy.sleep(240)
	self.heatOFF_pub.publish(Empty())

        return 'succeeded'

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
def connect_with_arduino():
	global send_str
	port = rospy.get_param('steer_motor_port',"/dev/ttyUSB0")
	pub = rospy.Publisher('motor_controller_input', String, queue_size=10)
	pub_str = String()
	print port
	try:
		ser = serial.Serial(port,9600)
		ser.setDTR(False)
		time.sleep(1)
		ser.setDTR(True)
		print "start connection with steer_motor"

	except:
		print "cannot start connection with steer_motor"
		sys.exit()

	time.sleep(2)
	rate = rospy.Rate(100)

	count = 0
	while count < 4:
		count += 1
		send_zero_to_steer_motor(ser)
		rate.sleep()

	print "Did You Turn On a Motor Switch??"

	wait_count = 0
	while  not wait_count > 200:
		ser.write("EN\n")
		ser.write("NP\n")
		while ser.inWaiting() > 0:
			if ser.read() == "p":
				ser.write("EN\n")
				send_devision_to_steer_motor(ser)				
				pub_str.data = send_str[:-1]
				pub.publish(pub_str)
		rate.sleep()
		wait_count = wait_count + 1


	print "Control Start"

	while  not rospy.is_shutdown():
		if enable_motor == True:
			ser.write("NP\n")
			while ser.inWaiting() > 0:
				if ser.read() == "p":
					ser.write("EN\n")
					send_devision_to_steer_motor(ser)				
					pub_str.data = send_str[:-1]
					pub.publish(pub_str)
		else:
			ser.write("DI\n")

		rate.sleep()

	ser.close()

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
def publishSimulatedFeedback(bestShape_index, shapeType_index, doGroupwiseComparison):           
        feedback = String();
        if(doGroupwiseComparison):
            feedback.data = str(shapeType_index) + '_' + str(bestShape_index);
        else:
            names = ('old', 'new');
            feedback.data = names[bestShape_index];            
        onFeedbackReceived(feedback);

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
    def callback_sub_msg(self, msg):
        try:
            symbol = String()
            symbol.data = chr(msg.data)
        except ValueError:
            symbol.data = "Symbol not exist!"

        self.pub.publish(symbol)

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
    def _on_approach_pressed(self):
	str = String()
	str.data = "getposition"
	self._publishersys.publish(str)
	d = rospy.Duration(0.2,0)
	rospy.sleep(d)
	str.data = "approach_victim"
	self._publishersys.publish(str)
	self._widget.victim_label.setText('Approach Victim..')

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
 def execute(self, userdata):
     my_string = String()
     my_string.data = "Start charging."
     self.charge_pub.publish(Empty())
     self.string_pub.publish(my_string)
     rospy.loginfo("Charging... Sleep 2 hours")
     rospy.sleep(2.1*60.0*60.0)
     my_string.data = "Charge done."
     self.string_pub.publish(my_string)
     return 'succeeded'

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
    def _on_sensor_pressed(self):
        str = String()
	if RobotSteering.modesensor :
		self._widget.sensor_button.setText('Stop_Sensor')
		RobotSteering.modesensor = False
		str.data = "start_sensor"
	else :
		self._widget.sensor_button.setText('Start_Sensor')
		RobotSteering.modesensor = True
		str.data = "stop_sensor"
        self._publishersys.publish(str)

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
    def _on_mode_pressed(self):
	str = String()
	if RobotSteering.mode :
		self._widget.mode_push_button.setText('Auto_Mode')
		RobotSteering.mode = False
		str.data = "teleop_mode"
	else :
		self._widget.mode_push_button.setText('Teleop_Mode')
		RobotSteering.mode = True
		str.data = "auto_mode"
        self._publishersys.publish(str)

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
def output():
  global out
  global select
  pub = rospy.Publisher('psoc_cmd',String)
  while not rospy.is_shutdown():
    p = String()
    if select is LEFT:
      p.data = ">FLPC:"+str(out)
    elif select is RIGHT:
      p.data = ">FRPC:"+str(out)
    pub.publish(p)
    time.sleep(.1)

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
def demo():
    rospy.init_node('Case2016_Demo')
    pub = rospy.Publisher('CModelRobotOutput', outputMsg.CModel_robot_output)
    pub_arm = rospy.Publisher('/ur_driver/URScript', String)
    rospy.Subscriber("/hands", Hands, h_call)    
    rospy.Subscriber("/faces", Faces, f_call)    
    rospy.Subscriber("/bluetooth_teleop/joy", Joy, joy_call)    

    command = outputMsg.CModel_robot_output();
    pub.publish(command) #Reset
    command.rACT = 1
    command.rGTO = 1
    command.rSP = 255
    command.rFR = 75 
    pub.publish(command) #Activate 

    # Arm Control
    val = String()
    arm_array = [-3.84, -2.1, 1.22, 0.61, 1.57, 0]

    while not rospy.is_shutdown():
        if safe == 1: #Autonomous mode
            print "Auto"
            command.rPR = state
            pub.publish(command)
            global target
            arm_array[0] = arm_array[0] + target[0]*0.001
            arm_array[2] = arm_array[2] + target[1]*0.001
            target = [0,0]
            val.data = "movej(" + str(arm_array) +", a=0.1, v=0.1)"
            pub_arm.publish(val)
            print val.data


        if safe == 2: #Manual mode
            print "Manual"
            scale = 0.1
            if joy.buttons[12] == 1: command.rPR = 0
            if joy.buttons[14] == 1: command.rPR = 255
            if joy.buttons[11] == 1: arm_array = home[:]
            pub.publish(command)
            arm_array[0] = arm_array[0] + joy.axes[0]*scale #base angle value of arm, left analog stick
            arm_array[1] = arm_array[1] + joy.axes[1]*scale #shoulder value of arm, left analog stick
            arm_array[2] = arm_array[2] + joy.axes[2]*scale #elbow value of arm, right analog stick
            arm_array[3] = arm_array[3] + joy.axes[3]*scale #wrist1 value of arm, right analog stick
            #arm_array[4] = arm_array[4] + joy.axes[3]*scale #wrist2 value of arm, right analog stick
            #arm_array[5] = arm_array[5] + joy.axes[3]*scale #wrist3 value of arm, right analog stick
            val.data = "movej(" + str(arm_array) +", a=0.5, v=1.0)"
            pub_arm.publish(val)
            print val.data

        
        rospy.sleep(0.8)

# 需要导入模块: from std_msgs.msg import String [as 别名]
# 或者: from std_msgs.msg.String import data [as 别名]
def output():
  global leftOut
  global rightOut
  pub = rospy.Publisher('psoc_cmd',String)
  while not rospy.is_shutdown():
    p = String()
    p.data = ">SPLM:"+str(leftOut)
    pub.publish(p)
    p = String()
    p.data = ">SPRM:"+str(rightOut)
    pub.publish(p)
    time.sleep(.1)