How to Control Robots with Python: A Comprehensive Guide

Instructions:

1. Install Python: Download the latest Python 3.x from python.org if you don't have it. Most Linux distributions come with Python pre-installed.
2. Create a Virtual Environment: Open your terminal or command prompt and navigate to your project directory. Run:

   python3 -m venv .venv

3. Activate the Virtual Environment:
   • Linux/macOS:

     source .venv/bin/activate

   • Windows (Command Prompt):

     .venv\Scripts\activate

   • Windows (PowerShell):

     .venv\Scripts\Activate.ps1

4. Install pip: Python's package installer, `pip`, is usually included with Python installations. Ensure it's up-to-date:

   pip install --upgrade pip

Prerequisites:

• ROS Installation: Follow official ROS documentation for your Linux distribution (Ubuntu recommended). Ensure you install a version that supports Python 3 (e.g., ROS Noetic or ROS 2).
• ROS Workspace: Set up a Catkin workspace.

sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'
sudo apt install curl # if you haven't already installed curl
curl -s https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc | sudo apt-key add -
sudo apt update
sudo apt install ros-noetic-desktop-full

# Environment setup
echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc
source ~/.bashrc

# Install rospy
sudo apt install ros-noetic-rospy ros-noetic-std-msgs

Instructions:

1. Create a ROS Package: Navigate to your Catkin workspace's src directory and create a new package:

   cd ~/catkin_ws/src
   catkin_create_pkg my_robot_control rospy std_msgs

2. Create a Publisher Node (talker.py): Inside ~/catkin_ws/src/my_robot_control/scripts/, create talker.py:

   #!/usr/bin/env python3
   import rospy
   from std_msgs.msg import String
   
   def talker():
       # Initialize the node with a unique name
       rospy.init_node('simple_talker', anonymous=True)
       # Create a publisher to the 'chatter' topic, message type String
       pub = rospy.Publisher('chatter', String, queue_size=10)
       # Set the publishing rate to 10 Hz
       rate = rospy.Rate(10) # 10hz
   
       rospy.loginfo("Simple ROS Talker Node Started")
   
       while not rospy.is_shutdown():
           hello_str = "Hello from Python ROS! %s" % rospy.get_time()
           pub.publish(hello_str)
           rate.sleep()
   
   if __name__ == '__main__':
       try:
           talker()
       except rospy.ROSInterruptException:
           pass
   

3. Make Executable:

   chmod +x ~/catkin_ws/src/my_robot_control/scripts/talker.py

4. Build Workspace:

   cd ~/catkin_ws
   catkin_make

5. Source Setup:

   source devel/setup.bash

   (Do this in every new terminal or add to .bashrc).
6. Run ROS Core:

   roscore

   (in a new terminal).
7. Run the Node:

   rosrun my_robot_control talker.py

   (in another new terminal).
8. Verify: In a fourth terminal, check messages:

   rostopic echo /chatter

Benefits of Simulation:

• Safety: Test dangerous maneuvers without risk.
• Cost-Effective: Reduce wear and tear on physical robots.
• Rapid Iteration: Quickly test code changes.
• Accessibility: Develop and learn robotics without owning expensive hardware.
• Debugging: Easier to inspect internal states and variables.

Instructions:

1. Install PyBullet: Activate your virtual environment and run:

   pip install pybullet numpy

2. Create a Simulation Script (simple_sim.py): This example loads a plane and a simple cube.

   import pybullet as p
   import pybullet_data
   import time
   
   # Connect to the physics engine (GUI mode for visualization)
   p.connect(p.GUI) # Or p.DIRECT for non-graphical mode
   
   # Reset simulation and set gravity
   p.resetSimulation()
   p.setGravity(0, 0, -9.8) # Earth's gravity
   
   # Add a search path for default PyBullet data (like planes, robots)
   p.setAdditionalSearchPath(pybullet_data.getDataPath())
   
   # Load a plane (ground)
   plane_id = p.loadURDF("plane.urdf")
   
   # Load a simple cube
   cube_start_position = [0, 0, 1] # x, y, z
   cube_start_orientation = p.getQuaternionFromEuler([0, 0, 0])
   cube_id = p.loadURDF("cube.urdf", cube_start_position, cube_start_orientation)
   
   print("PyBullet simulation started. Press Ctrl+C to exit.")
   
   try:
       # Run the simulation
       while True:
           p.stepSimulation()
           time.sleep(1./240.) # Simulate at 240 Hz (common timestep)
   
   except KeyboardInterrupt:
       print("Simulation stopped by user.")
   finally:
       p.disconnect() # Disconnect from the physics engine
       print("PyBullet disconnected.")
   

3. Run the Script:

   python simple_sim.py

   You should see a GUI window with a plane and a falling cube.