# 常用指令
sudo apt update # 更新软件包列表
sudo apt upgrade # 将软件包升级到最新版本

wget http://fishros.com/install -O fishros && . fishros

sudo apt install snap # 安装snap工具，系统可能已经自带
sudo snap install --classic code # 安装VS Code

wget http://fishros.com/install -O fishros && . fishros
# 输入密码后，输入7选择一键安装VsCode

sudo apt install ros-humble-turtlesim # 安装海龟功能包
# 安装make编译工具
sudo apt install make
# 安装cmake
sudo apt install cmake
# 安装构建工具colcon
sudo apt-get install python3-colcon-common-extensions
# 安装图形界面可视化工具RQT
sudo apt install ros-humble-rqt* 

# 安装依赖工具，使用鱼香ros提供的国内版,选择一键配置rosdep即可
wget http://fishros.com/install -O fishros && . fishros

# 设置始终执行该脚本文件,使ros2的软件包可在所有打开的新终端中使用
echo "source /opt/ros/humble/setup.bash" >> ~/.bashrc 

# 机器人运动控制
sudo apt-get install ros-humble-teleop-twist-keyboard
ros2 run teleop_twist_keyboard teleop_twist_keyboard

# 安装tf树插件
sudo apt install ros-humble-rqt-tf-tree

sudo apt update
sudo apt upgrade # 将软件包升级到最新版本
# 安装git
sudo apt install git
# 查看git版本，检查安装结果
git --version
# git配置
git config --global user.name "Your Name"
git config --global user.email "youremail@yourdomain.com"
# 验证git配置结果
git config --list

# 配置SSH
ssh-keygen -t rsa -C "这里换上你的邮箱"
# 回车3-4次
# 命令执行结束之后，home目录下面会生成.ssh目录

ssh -T git@github.com #测试是否配置成功

# 使用Git,请参照其他教程
git add xxx
git commit -m "xxxxxx"
git push origin master

# 安装gazebo仿真软件
sudo apt install gazebo
# 安装gazebo-ros功能包（所有）
sudo apt install ros-humble-gazebo-*
# 安装gazebo_ros插件
sudo apt install ros-humble-gazebo-ros
# 测试是否安装成功
gazebo --verbose -s libgazebo_ros_init.so -s libgazebo_ros_factory.so 
# 安装gazebo模型库（可选）
cd ~/.gazebo && wget https://gitee.com/ohhuo/scripts/raw/master/gazebo_model.py && python3 gazebo_model.py

sudo apt install ros-humble-cartographer
sudo apt install ros-humble-cartographer-ros

# 查看cartographer源码
git clone https://ghproxy.com/https://github.com/ros2/cartographer.git -b ros2
git clone https://ghproxy.com/https://github.com/ros2/cartographer_ros.git -b ros2

# 安装nav2
sudo apt install ros-humble-nav2-*
# 检查安装结果
ros2 pkg list | grep navigation2

# 查看nav2源码，结果为navigation2
git clone https://ghproxy.com/https://github.com/ros-planning/navigation2.git -b humble

,
"/opt/ros/humble/include/**"

source /opt/ros/humble/setup.bash

pip install setuptools==58.2.0

ps aux | grep gazebo

user     1234  0.0  0.1 123456 12345 ?        S    12:34   0:00 /usr/bin/gzserver ...
user     5678  0.0  0.1 234567 23456 ?        S    12:34   0:00 /usr/bin/gzclient ...
user     9101  0.0  0.0  1234  1234 pts/1    S+   12:35   0:00 grep --color=auto gazebo

kill -9 1234 5678

# 运行节点
ros2 run <package_name> <executable_name>
# 示例
ros2 run turtlesim turtlesim_node # 运行海龟
# 查看节点列表
ros2 node list
# 查看节点信息
ros2 node info <node_name>
# 示例
ros2 node info /turtlesim # 查看/turtlesim节点的详细信息

# 重映射节点名称
ros2 run turtlesim turtlesim_node --ros-args --remap __node:=my_turtle
# 运行节点时设置参数
ros2 run example_parameters_rclcpp parameters_basic --ros-args -p rcl_log_level:=10

ros2 topic -h

ros2 topic list
ros2 topic list -t
ros2 topic info /chatter
ros2 topic echo /chatter # 查看话题数据
ros2 topic hz /turtle1/pose # 查看话题发布频率

# 查看消息类型
ros2 interface show std_msgs/msg/String

# ros2 topic pub topic_name msg_type msg_data args
# 手动发布话题消息,--once是一个可选参数，表示发布一条消息然后退出，若要以频率n HZ发布则使用--rate n
ros2 topic pub --once /turtle1/cmd_vel geometry_msgs/msg/Twist "{linear: {x: 2.0, y: 0.0, z: 0.0}, angular: {x: 0.0, y: 0.0, z: 1.8}}"  
# 示例2
ros2 topic pub /chatter std_msgs/msg/String 'data: "123"'

# 关系可视化
rqt_graph

ros2 service list # 查看服务列表
ros2 service list -t # 查看服务列表

#ros2 service type service_name
ros2 service type /spawn # 查看服务接口类型
ros2 service find turtlesim/srv/Spawn # 查找特定接口类型的所有服务

# 手动调用服务
#ros2 service call service_name service_type service_data args
ros2 service call /add_two_ints example_interfaces/srv/AddTwoInts "{a: 5,b: 10}"
ros2 service call /spawn turtlesim/srv/Spawn "{x: 2, y: 2, theta: 0.2, name: ''}"

ros2 action list
ros2 action list -t

# ros2 action info action_name
ros2 action info /turtle1/rotate_absolute
#ros2 action send_goal action_name action_type action_data
ros2 action send_goal /turtle1/rotate_absolute turtlesim/action/RotateAbsolute "{theta: 1.6}"
# 示例2，增加feedback
ros2 action send_goal /turtle1/rotate_absolute turtlesim/action/RotateAbsolute "{theta: 1.5}" --feedback

ros2 interface list # 查看通信接口列表
ros2 interface show action_mags/msg/GoalInfo # 查看接口消息类型
#  ros2 interface package package_name
ros2 interface package turtlesim # 查看功能包中的通信接口

# xxx.msg
int64 num

# xxx.srv

#请求
int64 a
int64 b
---
#响应
int64 sum

# xxx.action

int32 order
---
int32[] sequence
---
int32[] partial_sequence

bool
byte
char
float32,float64
int8,uint8
int16,uint16
int32,uint32
int64,uint64
string

ros2 param list # 查看参数列表
# ros2 param get node_name parameter_name
ros2 param get /turtlesim background_g # 获取参数值
# ros2 param describe <node_name> <param_name>
ros2 param describe /turtlesim background_b
# ros2 param set <node_name> <parameter_name> <value>
ros2 param set /turtlesim background_g 150 # 设置参数值

# ros2 param dump <node_name>
ros2 param dump /turtlesim
#示例2 增加文件名
ros2 param dump /turtlesim > turtlesim.yaml # 保存参数到文件turtlesim.yaml
# 查看文件
cat ./turtlesim.yaml
# ros2 param load node_name parameter_file
ros2 param load /turtlesim ./turtlesim.yaml # 加载文件参数值
#ros2 param load /turtlesim turtlesim.yaml

# Replace ".bash" with your shell if you're not using bash
# Possible values are: setup.bash, setup.sh, setup.zsh
source /opt/ros/humble/setup.bash

sudo apt install ros-<version>-package_name

rosdep install -i --from-path src --rosdistro humble -y

# 部分示例
ros2 pkg create <package-name>  --build-type  {cmake,ament_cmake,ament_python}  --dependencies <依赖名字>
ros2 pkg executables
ros2 pkg executables turtlesim
ros2 pkg list
ros2 pkg prefix  <package-name>

# 在src目录下
# ros2 pkg create --build-type ament_python <package_name>
ros2 pkg create --build-type ament_python --node-name my_node my_package
# 官方指令
ros2 pkg create <pkg-name> --dependencies [deps] --build-type ament_python

# 更多的参数
cd chapt3/chapt3_ws/src
ros2 pkg create example_service_rclpy --build-type ament_python --dependencies rclpy example_interfaces  --node-name service_server_02
# --node-name 只支持一个节点文件

<!--这申明了当该软件包的代码被执行时需要rclcpp和std_msgs库。-->
<depend>rclpy</depend>
<depend>std_msgs</depend>

# setup.py
entry_points={
        'console_scripts': [
            'my_script = my_package.my_script:main'
        ],
    },

# 示例
    entry_points={
        'console_scripts': [
            "node_02 = example_py.node_02:main"
        ],
    },
#c console_scripts是个数组

# 在src 目录下
# ros2 pkg create --build-type ament_cmake <package_name>
ros2 pkg create --build-type ament_cmake --node-name my_node my_package
# 官方指令
ros2 pkg create <pkg-name> --dependencies [deps] --build-type ament_cmake

find_package(rclcpp REQUIRED)
find_package(std_msgs REQUIRED)

ament_target_dependencies(<executable-name> [dependencies])

# 示例，参考附录二
add_executable(node_01 src/node_01.cpp)
ament_target_dependencies(node_01 rclcpp)

# Install launch files
install(
  DIRECTORY launch
  DESTINATION share/${PROJECT_NAME}
)

# Install nodes
install(
  TARGETS [node-names]
  DESTINATION lib/${PROJECT_NAME}
)

# 工作空间下
rosdep install -i --from-path src --rosdistro <distro> -y

colcon build
source install/setup.bash
ros2 run my_package my_node
# 仅构建指定包
colcon build --packages-select YOUR_PKG_NAME 

cmake_minimum_required(VERSION 3.5)
project(examples_rclcpp_minimal_publisher)

# Default to C++14
if(NOT CMAKE_CXX_STANDARD)
  set(CMAKE_CXX_STANDARD 14)
endif()

if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()

find_package(ament_cmake REQUIRED)
find_package(rclcpp REQUIRED)
find_package(std_msgs REQUIRED)

add_executable(publisher_lambda lambda.cpp)
ament_target_dependencies(publisher_lambda rclcpp std_msgs)

add_executable(publisher_member_function member_function.cpp)
ament_target_dependencies(publisher_member_function rclcpp std_msgs)

add_executable(publisher_member_function_with_type_adapter member_function_with_type_adapter.cpp)
ament_target_dependencies(publisher_member_function_with_type_adapter rclcpp std_msgs)

add_executable(publisher_member_function_with_unique_network_flow_endpoints member_function_with_unique_network_flow_endpoints.cpp)
ament_target_dependencies(publisher_member_function_with_unique_network_flow_endpoints rclcpp std_msgs)

add_executable(publisher_wait_for_all_acked member_function_with_wait_for_all_acked.cpp)
ament_target_dependencies(publisher_wait_for_all_acked rclcpp std_msgs)

add_executable(publisher_not_composable not_composable.cpp)
ament_target_dependencies(publisher_not_composable rclcpp std_msgs)

install(TARGETS
  publisher_lambda
  publisher_member_function
  publisher_member_function_with_type_adapter
  publisher_member_function_with_unique_network_flow_endpoints
  publisher_wait_for_all_acked
  publisher_not_composable
  DESTINATION lib/${PROJECT_NAME}
)

if(BUILD_TESTING)
  find_package(ament_lint_auto REQUIRED)
  ament_lint_auto_find_test_dependencies()
endif()

ament_package()

cd proj_ws/src/my_package
mkdir launch
cd launch
touch xxxx.launch.py

# Install launch files.
install(DIRECTORY
  launch
  DESTINATION share/${PROJECT_NAME}/
)

install(DIRECTORY
  config
  DESTINATION share/${PROJECT_NAME}/
)

# For Python packages, your directory should look like this:
src/
  py_launch_example/
    launch/
    package.xml
    py_launch_example/
    resource/
    setup.cfg
    setup.py
    test/

# setup.py
import os
from glob import glob
from setuptools import setup

package_name = 'py_launch_example'

setup(
    # Other parameters ...
    data_files=[
        # ... Other data files
        # Include all launch files.
        (os.path.join('share', package_name, 'launch'), glob(os.path.join('launch', '*launch.[pxy][yma]*')))
    ]
)

# 其他参考
    data_files=[
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
        (os.path.join('share', package_name, 'launch'), glob('launch/*.launch.py')),
        (os.path.join('share', package_name, 'urdf'), glob('urdf/**')),
        (os.path.join('share', package_name, 'world'), glob('world/**')),
    ],

# simple.launch.py
from launch import LaunchDescription           # launch文件的描述类
from launch_ros.actions import Node            # 节点启动的描述类

def generate_launch_description():             # 自动生成launch文件的函数
    return LaunchDescription([                 # 返回launch文件的描述信息
        Node(                                  # 配置一个节点的启动
            package='learning_topic',          # 节点所在的功能包
            executable='topic_helloworld_pub', # 节点的可执行文件
        ),
        Node(                                  # 配置一个节点的启动
            package='learning_topic',          # 节点所在的功能包
            executable='topic_helloworld_sub', # 节点的可执行文件名
        ),
    ])

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
   return LaunchDescription([

   ])

# remapping.launch.py
from launch import LaunchDescription      # launch文件的描述类
from launch_ros.actions import Node       # 节点启动的描述类

def generate_launch_description():        # 自动生成launch文件的函数
    return LaunchDescription([            # 返回launch文件的描述信息
        Node(                             # 配置一个节点的启动
            package='turtlesim',          # 节点所在的功能包
            namespace='turtlesim1',       # 节点所在的命名空间
            executable='turtlesim_node',  # 节点的可执行文件名
            name='sim'                    # 对节点重新命名
        ),
        Node(                             # 配置一个节点的启动
            package='turtlesim',          # 节点所在的功能包
            namespace='turtlesim2',       # 节点所在的命名空间
            executable='turtlesim_node',  # 节点的可执行文件名
            name='sim'                    # 对节点重新命名
        ),
        Node(                             # 配置一个节点的启动
            package='turtlesim',          # 节点所在的功能包
            executable='mimic',           # 节点的可执行文件名
            name='mimic',                 # 对节点重新命名
            remappings=[                  # 资源重映射列表
                ('/input/pose', '/turtlesim1/turtle1/pose'),         
                ('/output/cmd_vel', '/turtlesim2/turtle1/cmd_vel'), 
            ]
        )
    ])
# 最后一个节点也来自turtlesim软件包，但其可执行文件不同，其可执行文件为mimic。
# 将/input/pose话题名修改为/turtlesim1/turtle1/pose
# 将/output/cmd_vel话题名修改为/turtlesim2/turtle1/cmd_vel

ros2 run rviz2 rviz2 -d <PACKAGE-PATH>/rviz/turtle_rviz.rviz

# rviz.launch.py
import os

from ament_index_python.packages import get_package_share_directory # 查询功能包路径的方法

from launch import LaunchDescription    # launch文件的描述类
from launch_ros.actions import Node     # 节点启动的描述类

def generate_launch_description():      # 自动生成launch文件的函数
   rviz_config = os.path.join(          # 找到配置文件的完整路径
      get_package_share_directory('learning_launch'),
      'rviz',
      'turtle_rviz.rviz'
      )

   return LaunchDescription([           # 返回launch文件的描述信息
      Node(                             # 配置一个节点的启动
         package='rviz2',               # 节点所在的功能包
         executable='rviz2',            # 节点的可执行文件名
         name='rviz2',                  # 对节点重新命名
         arguments=['-d', rviz_config]  # 加载命令行参数
      )
   ])

example_cmd = ExecuteProcess(
    cmd=['some-cmd', 'some-cmd'], #命令，用逗号隔开
    additional_env={'EXAMPLE_PATH': path}, #可以添加临时的环境变量
    output='screen'
)

ld.add_action(example_cmd)

# parameters.launch.py
from launch import LaunchDescription                   # launch文件的描述类
from launch.actions import DeclareLaunchArgument       # 声明launch文件内使用的Argument类
from launch.substitutions import LaunchConfiguration, TextSubstitution

from launch_ros.actions import Node                    # 节点启动的描述类

def generate_launch_description():                     # 自动生成launch文件的函数
   background_r_launch_arg = DeclareLaunchArgument(
      'background_r', default_value=TextSubstitution(text='0')     # 创建一个Launch文件内参数（arg）background_r
   )
   background_g_launch_arg = DeclareLaunchArgument(
      'background_g', default_value=TextSubstitution(text='84')    # 创建一个Launch文件内参数（arg）background_g
   )
   background_b_launch_arg = DeclareLaunchArgument(
      'background_b', default_value=TextSubstitution(text='122')   # 创建一个Launch文件内参数（arg）background_b
   )

   return LaunchDescription([                                      # 返回launch文件的描述信息
      background_r_launch_arg,                                     # 调用以上创建的参数（arg）
      background_g_launch_arg,
      background_b_launch_arg,
      Node(                                                        # 配置一个节点的启动
         package='turtlesim',
         executable='turtlesim_node',                              # 节点所在的功能包
         name='sim',                                               # 对节点重新命名
         parameters=[{                                             # ROS参数列表
            'background_r': LaunchConfiguration('background_r'),   # 创建参数background_r
            'background_g': LaunchConfiguration('background_g'),   # 创建参数background_g
            'background_b': LaunchConfiguration('background_b'),   # 创建参数background_b
         }]
      ),
   ])

# learning_launch/parameters_yaml.launch.py
import os
from ament_index_python.packages import get_package_share_directory  # 查询功能包路径的方法
from launch import LaunchDescription   # launch文件的描述类
from launch_ros.actions import Node    # 节点启动的描述类


def generate_launch_description():     # 自动生成launch文件的函数
   config = os.path.join(              # 找到参数文件的完整路径
      get_package_share_directory('learning_launch'),
      'config',
      'turtlesim.yaml'
      )

   return LaunchDescription([          # 返回launch文件的描述信息
      Node(                            # 配置一个节点的启动
         package='turtlesim',          # 节点所在的功能包
         executable='turtlesim_node',  # 节点的可执行文件名
         namespace='turtlesim2',       # 节点所在的命名空间
         name='sim',                   # 对节点重新命名
         parameters=[config]           # 加载参数文件
      )
   ])

# namespaces.launch.py
import os
from ament_index_python.packages import get_package_share_directory  # 查询功能包路径的方法
from launch import LaunchDescription                 # launch文件的描述类
from launch.actions import IncludeLaunchDescription  # 节点启动的描述类
from launch.launch_description_sources import PythonLaunchDescriptionSource
from launch.actions import GroupAction               # launch文件中的执行动作
from launch_ros.actions import PushRosNamespace      # ROS命名空间配置

def generate_launch_description():                   # 自动生成launch文件的函数
   parameter_yaml = IncludeLaunchDescription(        # 包含指定路径下的另外一个launch文件
      PythonLaunchDescriptionSource([os.path.join(
         get_package_share_directory('learning_launch'), 'launch'),
         '/parameters_nonamespace.launch.py'])
      )

   parameter_yaml_with_namespace = GroupAction(      # 对指定launch文件中启动的功能加上命名空间
      actions=[
         PushRosNamespace('turtlesim2'),
         parameter_yaml]
      )

   return LaunchDescription([                        # 返回launch文件的描述信息
      parameter_yaml_with_namespace
   ])

ros2 launch <package_name> <launch_file_name>

<exec_depend>ros2launch</exec_depend>

ros2 launch <package_name> <launch_file_name> background_r:=255

# load_urdf_into_gazebo.launch.py

world_file_path = 'worlds/neighborhood.world'
pkg_path = os.path.join(get_package_share_directory(package_name))
world_path = os.path.join(pkg_path, world_file_path) 
# Include the Gazebo launch file,
# provided by the gazebo_ros package
mbot = IncludeLaunchDescription(
        PythonLaunchDescriptionSource([os.path.join(
            get_package_share_directory(package_name),'launch','mbot.launch.py'
        )]), launch_arguments={'use_sim_time': 'true', 'world':world_path}.items())
gazebo = IncludeLaunchDescription(
        PythonLaunchDescriptionSource([os.path.join(
            get_package_share_directory('gazebo_ros'), 'launch', 'gazebo.launch.py')]),
     ) 
# Run the spawner node from the gazebo_ros package. 
# The entity name doesn't really matter if you only have a single robot.
spawn_entity = Node(package='gazebo_ros', executable='spawn_entity.py',
                    arguments=['-topic', 'robot_description',
                               '-entity', 'mbot',
                               '-x', spawn_x_val,
                               '-y', spawn_y_val,
                               '-z', spawn_z_val,
                               '-Y', spawn_yaw_val],
                    output='screen')
# Launch them all!
return LaunchDescription([
    mbot,
    gazebo,
    spawn_entity,
])

# 加载世界模型
gazebo_world_path = os.path.join(pkg_share, 'world/fishbot.world')

# Start Gazebo server
start_gazebo_cmd =  ExecuteProcess(
    cmd=['gazebo', '--verbose','-s', 'libgazebo_ros_init.so', '-s', 'libgazebo_ros_factory.so', gazebo_world_path],
    output='screen')

rviz_config_file_path = 'rviz/urdf_gazebo_config.rviz'
default_rviz_config_path = os.path.join(pkg_share, rviz_config_file_path)
declare_rviz_config_file_cmd = DeclareLaunchArgument(
    name='rviz_config_file',
    default_value=default_rviz_config_path,
    description='Full path to the RVIZ config file to use')
declare_use_rviz_cmd = DeclareLaunchArgument(
    name='use_rviz',
    default_value='True',
    description='Whether to start RVIZ')
# Launch RViz
start_rviz_cmd = Node(
    package='rviz2',
    executable='rviz2',
    name='rviz2',
    output='screen',
    arguments=['-d', rviz_config_file])
ld.add_action(declare_rviz_config_file_cmd)
ld.add_action(declare_use_rviz_cmd) 
ld.add_action(start_rviz_cmd)

# 预处理Preprocessing
gcc -E test.c -o test.i
# 编译Compilation
gcc -S test.i -o test.s
# 汇编Assemble
gcc -c test.s -o test.o
# 链接Linking
gcc test.o -o test

// Simple Hello World program in C
#include<stdio.h>
int main()
{
    printf("Hello World!");
    return 0;
}

gcc -save-temps hello.c -o compilation

# 现在我们有源文件hello.c，下面是一些gcc的使用示例：
gcc -E hello.c -o hello.i   对hello.c文件进行预处理，生成了hello.i 文件
gcc -S hello.i -o hello.s    对预处理文件进行编译，生成了汇编文件
gcc -c hello.s -o hello.o  对汇编文件进行编译，生成了目标文件
gcc hello.o -o hello 对目标文件进行链接，生成可执行文件
gcc hello.c -o hello 直接编译链接成可执行目标文件
gcc -c hello.c 或 gcc -c hello.c -o hello.o 编译生成可重定位目标文件

# cmake_minimum_required 指定使用 CMake 的最低版本号
cmake_minimum_required(VERSION 3.10)

# set the project name
project(Tutorial)

# add the executable 需要指定生成可执行文件的名称和相关源文件
add_executable(Tutorial tutorial.cxx)

# 使用 find_package() 命令找到包
find_package(Qt4 4.7.0 REQUIRED) # CMake provides a Qt4 find-module

# 优化
add_executable(${PROJECT_NAME} tutorial.cpp)
# 生成可执行文件需要指定相关的源文件，如果有多个，那么就用空格隔开
add_executable(${PROJECT_NAME} a.cpp b.cpp c.cpp)

# 也可以用一个变量来表示这多个源文件
# set 命令指定 SRC_LIST 变量来表示多个源文件
# 用${var_name} 获取变量的值。
set(SRC_LIST a.cpp b.cpp c.cpp)
add_executable(${PROJECT_NAME}${SRC_LIST})

# target_link_libraries - 为target(目标) 添加需要动态链接库
target_link_libraries(<target> ... <item>... ...)
#设置要链接的库文件的名称
target_link_libraries(first_node rclcpp rcutils)

# 链接
TARGET_LINK_LIBRARIES(${PROJECT&#95;NAME}${PROJECT_SOURCE_DIR}/lib/hello.lib)

#include <iostream>
using namespace std;
int main()
{
    cout<<"welcome to VS code world!"<<endl;
    return 0;
}

cmake_minimum_required(VERSION 3.15)

# set the project name
project(Tutorial)

# add the executable
add_executable(Tutorial text01.cpp)

mkdir build
cd build
cmake ..
make

cmake -G"MinGW Makefiles" ..