基于Intel Edison、GY-80 10DOF IMU与ROS Kinetic的Gazebo导航标记方案问询

Got it, let's walk through the simplest feasible solution for your use case—running ROS Kinetic on Intel Edison, using only the GY-80 10DOF IMU to enable marker-based navigation in Gazebo (with a predefined floor plan) as a person wears the device and walks. Here's the step-by-step breakdown, optimized for minimal complexity:

1. 基础环境与IMU驱动搭建 #

• ROS Kinetic on Intel Edison: Since Edison is x86-based, follow the standard ROS Kinetic installation for x86 systems. Make sure to install core dependencies:

  sudo apt-get install ros-kinetic-imu-tools ros-kinetic-robot-localization ros-kinetic-rtimulib ros-kinetic-imu-msgs
  

• GY-80 IMU Driver: Use rtimulib—it’s a pre-built ROS package that natively supports the GY-80’s 10DOF sensors (MPU6050, HMC5883L, BMP180). After installation:
  • Calibrate the IMU (critical to reduce drift): Run rosrun rtimulib rtimulib_cal and follow the on-screen prompts to calibrate accelerometer, gyro, and magnetometer.
  • Configure the package to output sensor_msgs/Imu and sensor_msgs/MagneticField topics (default setup usually does this, double-check the launch file).

2. 行人航位推算（PDR）核心：仅用IMU定位 #

Without additional sensors, Pedestrian Dead Reckoning (PDR) is your only option for position tracking. Keep it simple with these components:

• Step Detection: Use the IMU’s Z-axis acceleration data to detect steps. Implement a basic threshold-based detector:
  • Listen to the /imu/data topic, track peaks in vertical acceleration (when you take a step, your body accelerates upward).
  • Count a step only if the peak exceeds a threshold (e.g., 1.2 m/s²) and is spaced at least 0.5 seconds from the last peak (to avoid noise).
• Step Length Estimation: Use a fixed average step length (e.g., 0.75m for most adults) for simplicity—no need for dynamic adjustment unless you want to add complexity later.
• Heading Tracking: Extract the yaw (heading) angle from the IMU’s fused orientation data (from /imu/data). This gives your walking direction.
• Position Calculation: Accumulate step-based movement to compute X/Y coordinates:
  • For each step, calculate delta X/Y using step_length * cos(yaw) and step_length * sin(yaw).
  • Publish the resulting position as a nav_msgs/Odometry topic for Gazebo and navigation logic.

3. Gazebo仿真环境对接 #

• Import Predefined Floor Plan: Convert your floor layout into a Gazebo SDF model, or use ros-kinetic-map-server to load a 2D occupancy grid map and spawn static obstacles (walls, doors) in Gazebo to match.
• Sync Pedestrian Model with PDR:
  • Spawn a simple model (e.g., a cube) in Gazebo to represent the walking person.
  • Write a lightweight ROS node that subscribes to your PDR’s /odom topic, then uses gazebo_ros services (like /gazebo/set_model_state) to update the model’s position and orientation in real-time.
• Place Navigation Markers: Add visible models (e.g., colored cylinders) in Gazebo at your predefined navigation points (e.g., room entrances, corners). Note their exact X/Y coordinates in the Gazebo world frame for later use.

4. 标记导航逻辑（给行人的指引） #

Since you’re guiding a person (not an autonomous robot), the navigation logic should provide simple, actionable cues:

• Set Target Marker: Create a ROS node that lets you input a target marker’s coordinates (e.g., via terminal command: rosrun your_package set_goal 5.0 3.0).
• Real-Time Guidance:
  • Subscribe to the PDR’s position data and compare it to the target coordinates.
  • Calculate the distance to the target and the required heading adjustment (e.g., "Turn left 15 degrees" or "Walk straight 3 meters").
  • Output these cues via a simple interface—for example, publish to a std_msgs/String topic that drives an LED indicator or a text-to-speech node (keep it simple; even terminal output works for testing).

5. 漂移修正（最简版） #

IMU drift will accumulate over time—fix this with manual calibration at markers:

• Add a simple trigger (e.g., a button press mapped to a ROS service) that resets the PDR’s current position to the known coordinates of the marker you’re standing at. This wipes out accumulated error and keeps your position accurate for the next leg of the journey.

Step Detector Node (Python) #

import rospy
from sensor_msgs.msg import Imu
from std_msgs.msg import Int32

step_count = 0
last_peak_time = 0
PEAK_THRESHOLD = 1.2  # Adjust based on your walking style
MIN_STEP_INTERVAL = 0.5  # Minimum time between steps (seconds)

def imu_callback(msg):
    global step_count, last_peak_time
    current_time = rospy.get_time()
    z_accel = msg.linear_acceleration.z
    
    if z_accel > PEAK_THRESHOLD and (current_time - last_peak_time) > MIN_STEP_INTERVAL:
        step_count += 1
        step_pub.publish(step_count)
        last_peak_time = current_time

if __name__ == '__main__':
    rospy.init_node('step_detector')
    rospy.Subscriber('/imu/data', Imu, imu_callback)
    step_pub = rospy.Publisher('/step_count', Int32, queue_size=10)
    rospy.spin()

PDR Position Calculator Node (Python) #

import rospy
from std_msgs.msg import Int32
from sensor_msgs.msg import Imu
from nav_msgs.msg import Odometry
import tf
import math

STEP_LENGTH = 0.75  # Your average step length
current_x = 0.0
current_y = 0.0
current_yaw = 0.0
last_step_count = 0

def step_callback(msg):
    global current_x, current_y, last_step_count, current_yaw
    if msg.data > last_step_count:
        steps_added = msg.data - last_step_count
        delta_x = steps_added * STEP_LENGTH * math.cos(current_yaw)
        delta_y = steps_added * STEP_LENGTH * math.sin(current_yaw)
        current_x += delta_x
        current_y += delta_y
        last_step_count = msg.data

def imu_orientation_callback(msg):
    global current_yaw
    quat = (msg.orientation.x, msg.orientation.y, msg.orientation.z, msg.orientation.w)
    euler = tf.transformations.euler_from_quaternion(quat)
    current_yaw = euler[2]  # Extract yaw (heading) angle

if __name__ == '__main__':
    rospy.init_node('pdr_localization')
    rospy.Subscriber('/step_count', Int32, step_callback)
    rospy.Subscriber('/imu/data', Imu, imu_orientation_callback)
    odom_pub = rospy.Publisher('/odom', Odometry, queue_size=10)
    rate = rospy.Rate(10)
    
    while not rospy.is_shutdown():
        odom_msg = Odometry()
        odom_msg.header.stamp = rospy.Time.now()
        odom_msg.header.frame_id = 'odom'
        odom_msg.child_frame_id = 'base_link'
        
        odom_msg.pose.pose.position.x = current_x
        odom_msg.pose.pose.position.y = current_y
        quat = tf.transformations.quaternion_from_euler(0, 0, current_yaw)
        odom_msg.pose.pose.orientation.x = quat[0]
        odom_msg.pose.pose.orientation.y = quat[1]
        odom_msg.pose.pose.orientation.z = quat[2]
        odom_msg.pose.pose.orientation.w = quat[3]
        
        odom_pub.publish(odom_msg)
        rate.sleep()

This solution prioritizes minimal complexity: it leverages pre-built ROS packages for IMU handling, uses basic PDR for localization, syncs with Gazebo for visualization, and provides simple guidance cues to the user. The manual marker calibration keeps drift in check without needing extra hardware.

内容的提问来源于stack exchange，提问作者Nauman Shakir