Python源码示例：rospy.is_shutdown()
示例1
def talker_ctrl():
global rate_value
# publishes to thruster and rudder topics
pub_motor = rospy.Publisher('thruster_command', JointState, queue_size=10)
pub_rudder = rospy.Publisher('joint_setpoint', JointState, queue_size=10)
rospy.init_node('usv_simple_ctrl', anonymous=True)
rate = rospy.Rate(rate_value) # 10h
# subscribe to state and targer point topics
rospy.Subscriber("state", Odometry, get_pose) # get usv position (add 'gps' position latter)
rospy.Subscriber("usv_position_setpoint", Odometry, get_target) # get target position
while not rospy.is_shutdown():
pub_motor.publish(thruster_ctrl_msg())
pub_rudder.publish(rudder_ctrl_msg())
rate.sleep()
示例2
def spin(self):
#############################################################
r = rospy.Rate(self.rate)
idle = rospy.Rate(10)
then = rospy.Time.now()
self.ticks_since_target = self.timeout_ticks
###### main loop ######
while not rospy.is_shutdown():
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.spinOnce()
r.sleep()
idle.sleep()
#############################################################
示例3
def spin(self):
#############################################################
r = rospy.Rate(self.rate)
idle = rospy.Rate(10)
then = rospy.Time.now()
self.ticks_since_target = self.timeout_ticks
###### main loop ######
while not rospy.is_shutdown():
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.spinOnce()
r.sleep()
idle.sleep()
#############################################################
示例4
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例5
def spin(self):
###############################################
r = rospy.Rate
self.secs_since_target = self.timeout_secs
self.then = rospy.Time.now()
self.latest_msg_time = rospy.Time.now()
rospy.loginfo("-D- spinning")
###### main loop #########
while not rospy.is_shutdown():
while not rospy.is_shutdown() and self.secs_since_target < self.timeout_secs:
self.spinOnce()
r.sleep
self.secs_since_target = rospy.Time.now() - self.latest_msg_time
self.secs_since_target = self.secs_since_target.to_sec()
#rospy.loginfo(" inside: secs_since_target: %0.3f" % self.secs_since_target)
# it's been more than timeout_ticks since we recieved a message
self.secs_since_target = rospy.Time.now() - self.latest_msg_time
self.secs_since_target = self.secs_since_target.to_sec()
# rospy.loginfo(" outside: secs_since_target: %0.3f" % self.secs_since_target)
self.velocity = 0
r.sleep
###############################################
示例6
def talker_ctrl():
global rate_value
rospy.init_node('usv_simple_ctrl', anonymous=True)
rate = rospy.Rate(rate_value) # 10h
# publishes to thruster and rudder topics
pub_motor = rospy.Publisher('thruster_command', JointState, queue_size=10)
pub_rudder = rospy.Publisher('joint_setpoint', JointState, queue_size=10)
pub_result = rospy.Publisher('move_usv/result', Float64, queue_size=10)
# subscribe to state and targer point topics
rospy.Subscriber("state", Odometry, get_pose) # get usv position (add 'gps' position latter)
rospy.Subscriber("move_usv/goal", Odometry, get_target) # get target position
while not rospy.is_shutdown():
try:
pub_motor.publish(thruster_ctrl_msg())
pub_rudder.publish(rudder_ctrl_msg())
pub_result.publish(verify_result())
rate.sleep()
except rospy.ROSInterruptException:
rospy.logerr("ROS Interrupt Exception! Just ignore the exception!")
except rospy.ROSTimeMovedBackwardsException:
rospy.logerr("ROS Time Backwards! Just ignore the exception!")
示例7
def navigation():
pub = rospy.Publisher('usv_position_setpoint', Odometry, queue_size=10) # only create a rostopic, navigation system TODO
rospy.init_node('navigation_publisher')
rate = rospy.Rate(60) # 10h
x = -20.0
y = -20.0
msg = Odometry()
# msg.header = Header()
msg.header.stamp = rospy.Time.now()
msg.header.frame_id = "navigation"
msg.pose.pose.position = Point(x, y, 0.)
while not rospy.is_shutdown():
pub.publish(msg)
rate.sleep()
示例8
def __init__(self, args):
self.index = 0
if len(sys.argv) > 1:
self.index = int(sys.argv[1])
rospy.init_node('save_img')
self.bridge = CvBridge()
while not rospy.is_shutdown():
raw_input()
data = rospy.wait_for_message('/camera1/usb_cam/image_raw', Image)
try:
cv_image = self.bridge.imgmsg_to_cv2(data, "passthrough")
except CvBridgeError as e:
print(e)
print "Saved to: ", base_path+str(self.index)+".jpg"
cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB, cv_image)
cv2.imwrite(join(base_path, "frame{:06d}.jpg".format(self.index)), cv_image)#*255)
self.index += 1
rospy.spin()
示例9
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例10
def spin(self):
###############################################
r = rospy.Rate
self.secs_since_target = self.timeout_secs
self.then = rospy.Time.now()
self.latest_msg_time = rospy.Time.now()
rospy.loginfo("-D- spinning")
###### main loop #########
while not rospy.is_shutdown():
while not rospy.is_shutdown() and self.secs_since_target < self.timeout_secs:
self.spinOnce()
r.sleep
self.secs_since_target = rospy.Time.now() - self.latest_msg_time
self.secs_since_target = self.secs_since_target.to_sec()
#rospy.loginfo(" inside: secs_since_target: %0.3f" % self.secs_since_target)
# it's been more than timeout_ticks since we recieved a message
self.secs_since_target = rospy.Time.now() - self.latest_msg_time
self.secs_since_target = self.secs_since_target.to_sec()
# rospy.loginfo(" outside: secs_since_target: %0.3f" % self.secs_since_target)
self.velocity = 0
r.sleep
###############################################
示例11
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例12
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例13
def spin(self):
#############################################################
r = rospy.Rate(self.rate)
idle = rospy.Rate(10)
then = rospy.Time.now()
self.ticks_since_target = self.timeout_ticks
###### main loop ######
while not rospy.is_shutdown():
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.spinOnce()
r.sleep()
idle.sleep()
#############################################################
示例14
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例15
def spin(self):
###############################################
r = rospy.Rate
self.secs_since_target = self.timeout_secs
self.then = rospy.Time.now()
self.latest_msg_time = rospy.Time.now()
rospy.loginfo("-D- spinning")
###### main loop #########
while not rospy.is_shutdown():
while not rospy.is_shutdown() and self.secs_since_target < self.timeout_secs:
self.spinOnce()
r.sleep
self.secs_since_target = rospy.Time.now() - self.latest_msg_time
self.secs_since_target = self.secs_since_target.to_sec()
#rospy.loginfo(" inside: secs_since_target: %0.3f" % self.secs_since_target)
# it's been more than timeout_ticks since we recieved a message
self.secs_since_target = rospy.Time.now() - self.latest_msg_time
self.secs_since_target = self.secs_since_target.to_sec()
# rospy.loginfo(" outside: secs_since_target: %0.3f" % self.secs_since_target)
self.velocity = 0
r.sleep
###############################################
示例16
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例17
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例18
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例19
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例20
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例21
def spinOnce(self):
#####################################################
self.previous_error = 0.0
self.prev_vel = [0.0] * self.rolling_pts
self.integral = 0.0
self.error = 0.0
self.derivative = 0.0
self.vel = 0.0
# only do the loop if we've recently recieved a target velocity message
while not rospy.is_shutdown() and self.ticks_since_target < self.timeout_ticks:
self.calcVelocity()
self.doPid()
self.pub_motor.publish(self.motor)
self.r.sleep()
self.ticks_since_target += 1
if self.ticks_since_target == self.timeout_ticks:
self.pub_motor.publish(0)
#####################################################
示例22
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--lr", default="r")
args = parser.parse_args()
rospy.init_node("pr2_target_policy")
with open('config/environment/pr2.yaml') as yaml_string:
pr2_env = utils.from_yaml(yaml_string)
tool_link_name = "%s_gripper_tool_frame" % args.lr
pol = policies.Pr2TargetPolicy(pr2_env, tool_link_name, np.zeros(3))
rate = rospy.Rate(30.0)
while not rospy.is_shutdown():
state = pr2_env.get_state()
target_state = pol.get_target_state()
action = (target_state - state) / pr2_env.dt
pr2_env.step(action)
# pr2_env.reset(pol.get_target_state())
rate.sleep()
示例23
def revalidate(self, timeout, invalidate_state=True, invalidate_config=True):
"""
invalidate the state and config topics, then wait up to timeout
seconds for them to become valid again.
return true if both the state and config topic data are valid
"""
if invalidate_state:
self.invalidate_state()
if invalidate_config:
self.invalidate_config()
timeout_time = rospy.Time.now() + rospy.Duration(timeout)
while not self.is_state_valid() and not rospy.is_shutdown():
rospy.sleep(0.1)
if timeout_time < rospy.Time.now():
rospy.logwarn("Timed out waiting for node interface valid...")
return False
return True
示例24
def spin(self):
#############################################################################
r = rospy.Rate(self.rate)
while not rospy.is_shutdown():
self.update()
r.sleep()
#############################################################################
示例25
def spin(self):
#####################################################
self.r = rospy.Rate(self.rate)
self.then = rospy.Time.now()
self.ticks_since_target = self.timeout_ticks
self.wheel_prev = self.wheel_latest
self.then = rospy.Time.now()
while not rospy.is_shutdown():
self.spinOnce()
self.r.sleep()
#####################################################
示例26
def run(self, update_rate=10):
"""
Publish data continuously with given rate.
:type update_rate: int
:param update_rate: The update rate.
"""
r = rospy.Rate(update_rate)
while not rospy.is_shutdown():
self._publish_tf(update_rate)
self._publish_image()
self._publish_objects()
self._publish_joint_state()
self._publish_imu()
self._publish_battery()
self._publish_odometry()
self._publish_diagnostics()
# send message repeatedly to avoid idle mode.
# This might cause low battery soon
# TODO improve this!
self._cozmo.drive_wheels(*self._wheel_vel)
# sleep
r.sleep()
# stop events on cozmo
self._cozmo.stop_all_motors()
示例27
def talker():
pub = rospy.Publisher('/barco_auv/thruster_command', JointState, queue_size=10)
rospy.init_node('ctrl_jointState_publisher', anonymous=True)
rate = rospy.Rate(10) # 10hz
hello_str = JointState()
hello_str.header = Header()
hello_str.name = ['fwd_left']
hello_str.position = [10]
hello_str.velocity = []
hello_str.effort = []
while not rospy.is_shutdown():
rospy.loginfo(hello_str)
pub.publish(hello_str)
rate.sleep()
示例28
def talker_ctrl():
global rate_value
global currentHeading
global windDir
global isTacking
global heeling
global spHeading
rospy.init_node('usv_simple_ctrl', anonymous=True)
rate = rospy.Rate(rate_value) # 10h
# publishes to thruster and rudder topics
#pub_sail = rospy.Publisher('angleLimits', Float64, queue_size=10)
pub_rudder = rospy.Publisher('joint_setpoint', JointState, queue_size=10)
pub_result = rospy.Publisher('move_usv/result', Float64, queue_size=10)
pub_heading = rospy.Publisher('currentHeading', Float64, queue_size=10)
pub_windDir = rospy.Publisher('windDirection', Float64, queue_size=10)
pub_heeling = rospy.Publisher('heeling', Float64, queue_size=10)
pub_spHeading = rospy.Publisher('spHeading', Float64, queue_size=10)
# subscribe to state and targer point topics
rospy.Subscriber("state", Odometry, get_pose) # get usv position (add 'gps' position latter)
rospy.Subscriber("move_usv/goal", Odometry, get_target) # get target position
while not rospy.is_shutdown():
try:
pub_rudder.publish(rudder_ctrl_msg())
#pub_sail.publish(sail_ctrl())
pub_result.publish(verify_result())
pub_heading.publish(currentHeading)
pub_windDir.publish(windDir)
pub_heeling.publish(heeling)
pub_spHeading.publish(spHeading)
rate.sleep()
except rospy.ROSInterruptException:
rospy.logerr("ROS Interrupt Exception! Just ignore the exception!")
except rospy.ROSTimeMovedBackwardsException:
rospy.logerr("ROS Time Backwards! Just ignore the exception!")
示例29
def navigation():
rospy.Publisher('usv_position_setpoint', Odometry) # only create a rostopic, navigation system TODO
rospy.spin()
# while not rospy.is_shutdown():
# rospy.loginfo(hello_str)
# pub.publish(hello_str)
# rate.sleep()
示例30
def __init__(self):
rospy.init_node('usv_vel_ctrl', anonymous=False)
self.rate = 10
r = rospy.Rate(self.rate) # 10hertz
self.usv_vel = Odometry()
self.usv_vel_ant = Odometry()
self.target_vel = Twist()
self.target_vel_ant = Twist()
self.thruster_msg = JointState()
self.rudder_msg = JointState()
self.thruster_msg.header = Header()
self.rudder_msg.header = Header()
self.kp_lin = 80
self.ki_lin = 200
thruster_name = 'fwd'
rudder_name = 'rudder_joint'
self.I_ant_lin = 0
self.I_ant_ang = 0
self.lin_vel = 0
self.lin_vel_ang = 0
self.ang_vel = 0
self.kp_ang = 2
self.ki_ang = 4
self.rudder_max = 70
self.thruster_max = 30
self.pub_motor = rospy.Publisher('thruster_command', JointState, queue_size=10)
self.pub_rudder = rospy.Publisher('joint_setpoint', JointState, queue_size=10)
rospy.Subscriber("state", Odometry, self.get_usv_vel)
rospy.Subscriber("cmd_vel", Twist, self.get_target_vel)
while not rospy.is_shutdown():
self.pub_rudder.publish(self.rudder_ctrl_msg(self.ang_vel_ctrl(), rudder_name))
self.pub_motor.publish(self.thruster_ctrl_msg(self.lin_vel_ctrl(), thruster_name))
r.sleep()
