Advanced Topics for Robotics 代做、代写C++设计程序

April 8, 2024
Advanced Topics for Robotics 
Homework 1

Introduction
In this assignment, you will learn and practice setting up the robotics development environments
and using a powerful open-source...

April 8, 2024
Advanced Topics for Robotics 
Homework 1
<!-- ## Instructions and Announcements
There is one programming problem in this assignment.
Before beginning this task, please be aware that you may need to configure a virtual machine
and install an operating system to complete this assignment.
Please record the result as a video and submit it together with your source code.
Collaboration policy. Discussions with others are strongly encouraged. However, you should
implement the idea on your own.
If you have any questions about this assignment, please don't hesitate to reach out to Prof.
Chen or the TA : ) -->
Introduction
In this assignment, you will learn and practice setting up the robotics development environments
and using a powerful open-source codebase to run Model Predictive Control (MPC) for a
quadrupedal robot. 
Specifically, you will first set up necessary development tools such as Robot Operating System
(ROS). ROS is a set of software libraries and tools that help you build robot applications, from
drivers to state-of-the-art algorithms, and with powerful developer tools. For more details, please
see ROS tutorials.
You will then install one of the state-of-the-art MPC solver called Optimal Control for Switched 
Systems (OCS2). OCS2 is a C++ toolbox that provides an efficient implementation of several
advanced MPC algorithms such as Sequential Quadratic Programming (SQP) and Differential
Dynamic Programming (DDP).
To begin with, you need to follow the step-by-step instructions to install and configure the
development environments as well as OCS2. Once you have completed the configuration, you will
receive 60% of the homework marks.
After completing the configuration, you will need to modify a bit of the OCS2 code based on the
given tips to enable the quadruped robot to execute two new gaits. This section will account for
40% of your mark for this assignment.
Please note:
Before beginning this task, please be aware that you may need to configure a virtual machine
and install an operating system to complete this assignment.
Collaboration policy. Discussions with others are encouraged. However, you should
implement the idea on your own.
If you have any questions about this assignment, please don't hesitate to reach out to Prof.
Chen or the TA : )
Prerequisites
The following are the prerequisites for compiling and running OCS2:
Ubuntu 20.04. We strongly recommend that you use the Ubuntu 20.04 operating system for
this assignment. OCS2 is tested under Ubuntu 20.04 with library versions as provided in the
package sources. If your computer's operating system is not Ubuntu 20.04, you can also use 
VMware to build a virtual machine. It is not recommended to use other common virtual
machines, such as Parallel Desktop and VirtualBox, because the limitation of graphics
memory may lead to poor rendering effects.
2-core processor (Intel/AMD CPU). 
The minimum requirement for the processor is 2-core, but we highly recommend
using 4-core processor.
6GB RAM.
While the minimum requirement for RAM is 6GB, we strongly suggest using 10GB RAM
for optimal performance.
30 GB of free hard disk space.
You can download the desktop image for Ubuntu 20.04 from: https://releases.ubuntu.com/20.04/ .
If your operating system is Windows or Linux, you may consider using VMware Workstation
Player as your virtual machine.
If your operating system is macOS, you may consider using VMware Fusion as your virtual
machine.
Dependencies
Please run sudo apt update && sudo apt upgrade in the command-line interface to ensure the
source of each package.
C++ compiler with C++11 support (Default package in Ubuntu 20.04).
Eigen (v3.3) (Default package in Ubuntu 20.04).
Boost C++ (v1.71) (Default package in Ubuntu 20.04).
ROS (Noetic). Ubuntu install of ROS Noetic.
GLPK, URDFDOM, OCTOMAP, ASSIMP sudo apt install libglpk-dev liburdfdom-dev
liboctomap-dev libassimp-dev .
catkin. (When you install ROS, it will be installed together.)
pybind11_catkin, ROS package, installable via sudo apt install ros-noetic-pybind11-
catkin ros-noetic-grid-map-rviz-plugin .
catkin-pkg package for python3. Install with sudo apt install python3-catkin-tools .
Doxygen for documentation. Install with sudo apt install doxygen doxygen-latex
Git. Install with sudo apt install git .
If you find that using the apt command is slow, you can refer to https://mirrors.tuna.tsinghua.ed
u.cn/help/ubuntu/ to change the source of apt. However, this is not a necessary step.
Installation and setup
1. Create a new catkin workspace:
Catkin is a build system used primarily within the Robot Operating System (ROS) ecosystem. It is
designed to manage the compilation, packaging, and distribution of multiple interdependent software
packages, or "packages," that make up a ROS project. Catkin streamlines the build process by handling
dependencies, ensuring that packages are built in the correct order, and allowing for easy integration
with other tools in the ROS ecosystem.
2. Clone the OCS2 and other necessary libraries:
Software packages used in the project are placed in the src folder of the workspace.
3. Remove packages that are not useful for this homework:
4. Build and run the unit tests:
# Create the directories
# Do not forget to change <...> parts
# You can use any <directory_to_ws> and <catkin_ws_name>.
# In my personal experiment,
# I choose `~/workstation`(without quotes) for <directory_to_ws>,
# and `hw1`(without quotes) for <catkin_ws_name>.
mkdir -p <directory_to_ws>/<catkin_ws_name>/src
cd <directory_to_ws>/<catkin_ws_name>/
# Initialize the catkin workspace
catkin init
catkin config --extend /opt/ros/noetic
catkin config -DCMAKE_BUILD_TYPE=RelWithDebInfo
# Navigate to the directory of src
# Do not forget to change <...> parts
cd <directory_to_ws>/<catkin_ws_name>/src
# Clone OCS2, pinocchio, hpp-fcl, and ocs2_robotic_assets.
git clone https://github.com/leggedrobotics/ocs2.git
git clone --recurse-submodules https://github.com/leggedrobotics/pinocchio.git
git clone --recurse-submodules https://github.com/leggedrobotics/hpp-fcl.git
git clone https://github.com/leggedrobotics/ocs2_robotic_assets.git
# Navigate to the directory of ocs2
# Do not forget to change <...> parts
cd <directory_to_ws>/<catkin_ws_name>/src/ocs2
rm -rf ocs2_mpcnet
rm -rf ocs2_raisim
# Navigate to the directory of src
cd <directory_to_ws>/<catkin_ws_name>/src
# Build it
catkin build ocs2
# Source it
source <directory_to_ws>/<catkin_ws_name>/devel/setup.bash
# run tests
catkin run_tests ocs2
The command source would load a configuration file for the bash. Note that each time you open a
new terminal for running your code in your ROS workspace, you need to source the corresponding bash
file in that workspace.
If you encounter the "C++: fatal error: Killed signal terminated program cc1plus" error in this
step, you can solve this issue by creating a swap partition as follows:
# Create partition paths.
sudo mkdir -p /var/cache/swap/
# Set the partition size.
# bs=64M is the block size, count=64 is the number of blocks,
# so the swap space size is bs*count=4096MB=4GB.
sudo dd if=/dev/zero of=/var/cache/swap/swap0 bs=64M count=64
# Set the directory permissions.
sudo chmod 0600 /var/cache/swap/swap0
# create SWAP file.
sudo mkswap /var/cache/swap/swap0
# Activate the SWAP file.
sudo swapon /var/cache/swap/swap0
# Check whether the SWAP information is correct.
sudo swapon -s
<!-- 5. Build the example for legged robots:
# Navigate to the directory of src
cd <directory_to_ws>/<catkin_ws_name>/src
catkin build ocs2_legged_robot_ros
``` -->
5. Run the example for legged robots:
``` bash
# Source workspace
# Do not forget to change <...> parts
source <directory_to_ws>/<catkin_ws_name>/devel/setup.bash
# Launch the example for SQP
roslaunch ocs2_legged_robot_ros legged_robot_sqp.launch
roslaunch is a command-line tool in the Robot Operating System (ROS) that allows users to start and
manage multiple ROS nodes and their configurations using a launch file. It simplifies the process of
initializing complex robotic systems, making it easy to run and manage multiple nodes with their
corresponding parameters and configurations in a coordinated manner.
The above launch file is placed in 
<directory_to_ws>/<catkin_ws_name>/src/ocs2/ocs2_robotic_examples/ocs2_legged_robot_
ros/launch/legged_robot_sqp.launch , which launches the corresponding software packages such
as MPC controller, gait scheduler and visualization.
And then, you can see a legged robot in the RViz window:
RViz, short for "ROS Visualization," is a 3D visualization tool for the Robot Operating System (ROS). It
provides a user-friendly interface to display sensor data, robot model representations, and other
relevant information in a 3D environment. RViz allows users to better understand the data collected by a
robot and offers a way to visualize the robot's state, movements, and interactions with its environment.
You should also see new terminal windows appear after you run the above roslaunch command.
One terminal is for specifying the gait type, please type trot in this terminal. Another terminal is
for specifying the destination for the robot to move to, please type 2 0 0 0 in this terminal.
Please record a video for your result to be submitted. In this way, you can get 60% points for this
homework. Feel free to play with this example by trying to enter any displacements and gaits in
the terminals. You can also explore the codebase if you are interested.
Design new gaits
You can simply modify 
<directory_to_ws>/<catkin_ws_name>/src/ocs2/ocs2_robotic_examples/ocs2_legged_robot/
config/command/gait.info to design two new gaits for the quadruped robot. 
When executing the trot gait, the quadruped robot's four feet will switch between the following
two patterns:
LF_RH: The left front (LF) and right hind (RH) feet are on the ground simultaneously, while the
right front and left hind feet are not.
RF_LH: The right front (RF) and left hind (LH) feet are on the ground simultaneously, while the
left front and right hind feet are not.
You need to now design two new gaits, galloping and jumping, each also switches between two
patterns, but the patterns are different from that of the trot gait.
For galloping, the two patterns are:
The left front and right front feet are on the ground simultaneously, while the left hind and
right hind feet are not.
The left hind and right hind feet are on the ground simultaneously, while the left front and
right front feet are not.
For jumping, the two patterns are:
All four feet are on the ground simultaneously, which is a stance pattern.
All four feet are in the air simultaneously, which is a fly pattern.
To complete it, you need to modify part 1 in the figure below and add some code similar to part 2.
Now, you are done with this assignment! Please remember to record the resulting video! Each gait
will constitute a 20% score.
Submit your homework
You need to pack the following four files into a zip file.
gait.info : the file you modified.
trot.mp4/.mpg : the video describes the result of running the example ( roslaunch
ocs2_legged_robot_ros legged_robot_sqp.launch ) with the built-in trot gait.
gallop.mp4/.mpg : the video to show the quadrupedal robot can do the galloping.
jumping.mp4/.mpg : the video to show the quadrupedal robot can do the jumping.
Note the videos should be in mp4 or mpg format. Then please name your zip file with your
student ID and submit it through Web Learning.

请加QQ：99515681  邮箱：99515681@qq.com   WX：codinghelp