24、基于ROS的配送服务机器人系统搭建

基于ROS的配送服务机器人系统搭建

1. 配送服务机器人概述

SLAM和导航技术在汽车、工厂生产线以及服务机器人等多个领域都有广泛应用，并且技术在不断进步。接下来，我们将基于已掌握的知识，构建一个实际可运行的配送服务机器人系统。

2. 配送服务机器人的配置

2.1 系统配置

配送服务机器人的系统设计可分为“服务核心（Service Core）”、“服务主节点（Service Master）”和“服务从节点（Service Slave）”，具体如下：
- 服务核心 ：它类似于一个数据库，负责管理客户的订单状态和机器人的服务执行状态。当收到客户订单时，它在处理订单和安排机器人服务流程方面起着关键作用。由于每个订单和处理系统都是独特的，且会影响其他客户的订单，所以服务核心必须是唯一的。
- 服务主节点 ：接收客户的订单，并将订单详情传递给服务核心。同时，它会显示可订购的物品列表，并向客户通知服务状态。为了实现这些功能，服务主节点的数据库必须与服务核心的数据库同步。
- 服务从节点 ：作为处理订单的机器人平台和实体对象，服务从节点会实时将订单的服务状态更新到服务核心。

2.2 系统设计

服务主节点、服务从节点和服务核心可以部署在一台计算机上，也可以分布式地部署在多台计算机上。但一台计算机可能无法处理所有工作，而过度分布到每台计算机又可能导致无线通信过载。因此，需要谨慎分配以确保正常处理。另外，由于ROS 1.x是为控制单个机器人而设计的系统，若要在多台计算机上使用ROS，需输入以下命令来减少计算机之间的时间差：

$ sudo ntpdate ntp.ubuntu.com

例如，可使用以下设备来实现配送服务机器人系统：
- 服务核心 ：NUC i5（3台计算机用于执行roscore和服务核心）
- 服务主节点 ：3台三星Note 10.4安卓系统平板电脑
- 服务从节点 ：3台搭载TurtleBot3 Carrier的英特尔Joule 570x（TurtleBot3 Waffle定制为配送机器人）

系统整体概念完成后，需要确定各区域节点之间应交换的消息。虽然一个平板可以监控多个机器人，但为简化系统结构，采用一个平板对应一个机器人的方式进行服务。下单的平板需将平板ID和所选物品信息发送到服务核心，服务核心根据平板ID确定指定哪个服务机器人执行工作，并发送相应的目标地点让机器人执行服务。服务机器人根据路径规划算法移动到接收的目标地点，在执行任务过程中，会传输机器人的服务状态，包括与障碍物的碰撞、路线失败、到达目标以及是否获取到订购物品等信息。服务核心会处理与订购物品相关的重复订单状态、机器人在服务期间收到的订单等信息，并通过平板呈现给客户。此过程中发送和接收的所有信息都使用自定义的新msg文件或srv文件。

以下是服务核心节点直接发送和接收的部分主题列表：
| 主题名称 | 说明 |
| ---- | ---- |
| /pad_order | 接收客户订单 |
| /move_base/action_topics | 接收机器人路径查找和目的地成功信息 |
| /service_status | 传递服务状态 |
| /play_sound_file | 传递录制语音文件的位置 |
| /move_base_simple/goal | 协调机器人的目标点 |

配送服务准备的流程图如下：

graph LR
    A[创建SLAM地图] --> B[确定服务位置]
    B --> C[记录坐标值]
    C --> D[在服务核心进行参数配置]

构建配送服务机器人所需的源代码可在以下地址获取： https://github.com/ROBOTIS-GIT/turtlebot3_deliver

2.3 服务核心节点

服务核心节点的源代码基本结构从 main() 函数开始，首先通过 fnInitParam() 函数设置ROS参数。之后，声明通过平板接收客户订单的 cbReceivePadOrder() 函数和接收机器人目标位置到达状态数据的 cbCheckArrivalStatus() 函数，以执行主题订阅。通过 fnPubServiceStatus() 和 fnPubPose() 函数发布服务状态和机器人坐标的目标位置。这个过程会在按下 [Ctrl + c] 键之前一直循环执行。

以下是 ServiceCore() 函数的部分代码：

ServiceCore()
{
  fnInitParam();
  pubServiceStatusPadTb3p = nh_.advertise<turtlebot3_carrier::ServiceStatus>("/tb3p/service_status", 1);
  pubServiceStatusPadTb3g = nh_.advertise<turtlebot3_carrier::ServiceStatus>("/tb3g/service_status", 1);
  pubServiceStatusPadTb3r = nh_.advertise<turtlebot3_carrier::ServiceStatus>("/tb3r/service_status", 1);
  pubPlaySoundTb3p = nh_.advertise<std_msgs::String>("/tb3p/play_sound_file", 1);
  pubPlaySoundTb3g = nh_.advertise<std_msgs::String>("/tb3g/play_sound_file", 1);
  pubPlaySoundTb3r = nh_.advertise<std_msgs::String>("/tb3r/play_sound_file", 1);
  pubPoseStampedTb3p = nh_.advertise<geometry_msgs::PoseStamped>("/tb3p/move_base_simple/goal", 1);
  pubPoseStampedTb3g = nh_.advertise<geometry_msgs::PoseStamped>("/tb3g/move_base_simple/goal", 1);
  pubPoseStampedTb3r = nh_.advertise<geometry_msgs::PoseStamped>("/tb3r/move_base_simple/goal", 1);
  subPadOrderTb3p = nh_.subscribe("/tb3p/pad_order", 1, &ServiceCore::cbReceivePadOrder, this);
  subPadOrderTb3g = nh_.subscribe("/tb3g/pad_order", 1, &ServiceCore::cbReceivePadOrder, this);
  subPadOrderTb3r = nh_.subscribe("/tb3r/pad_order", 1, &ServiceCore::cbReceivePadOrder, this);
  subArrivalStatusTb3p = nh_.subscribe("/tb3p/move_base/result", 1, &ServiceCore::cbCheckArrivalStatusTB3P, this);
  subArrivalStatusTb3g = nh_.subscribe("/tb3g/move_base/result", 1, &ServiceCore::cbCheckArrivalStatusTB3G, this);
  subArrivalStatusTb3r = nh_.subscribe("/tb3r/move_base/result", 1, &ServiceCore::cbCheckArrivalStatusTB3R, this);
  ros::Rate loop_rate(5);
  while (ros::ok())
  {
    fnPubServiceStatus();
    fnPubPose();
    ros::spinOnce();
    loop_rate.sleep();
  }
}

fnInitParam() 函数从给定的参数文件中获取机器人在地图上的目标位姿（位置 + 方向）数据。在这个例子中，机器人需要能够移动到三个客户下单的位置和三个获取订购物品的位置，因此需要存储地图上这六个位置的坐标信息。其结构如下：
| 项目 | 说明 |
| ---- | ---- |
| poseStampedTable | 客户下单和接收订单的坐标 |
| poseStampedCounter | 物品装载到机器人上的坐标 |

以下是 fnInitParam() 函数的部分代码：

void fnInitParam()
{
  nh_.getParam("table_pose_tb3p/position", target_pose_position);
  nh_.getParam("table_pose_tb3p/orientation", target_pose_orientation);
  poseStampedTable[0].header.frame_id = "map";
  poseStampedTable[0].header.stamp = ros::Time::now();
  poseStampedTable[0].pose.position.x = target_pose_position[0];
  poseStampedTable[0].pose.position.y = target_pose_position[1];
  poseStampedTable[0].pose.position.z = target_pose_position[2];
  poseStampedTable[0].pose.orientation.x = target_pose_orientation[0];
  poseStampedTable[0].pose.orientation.y = target_pose_orientation[1];
  poseStampedTable[0].pose.orientation.z = target_pose_orientation[2];
  poseStampedTable[0].pose.orientation.w = target_pose_orientation[3];
  // 其他位置的参数获取...
}

target_pose.yaml 文件中指示的参数值是机器人执行服务所需的地图上的坐标值。获取这些坐标值的方法有很多种，最简单的方法是使用 rostopic echo 命令在导航期间获取位姿值。但这些坐标会随着每次通过SLAM进行的地图绘制而改变，因此在实际导航过程中应避免重新绘制地图，以减少物体和障碍物的位置变化，从而可以继续使用同一地图。

target_pose.yaml 文件示例：

table_pose_tb3p:
  position: [-0.338746577501, -0.85418510437, 0.0]
  orientation: [0.0, 0.0, -0.0663151963596, 0.997798724559]
table_pose_tb3g:
  position: [-0.168751597404, -0.19147400558, 0.0]
  orientation: [0.0, 0.0, -0.0466624033917, 0.998910716786]
table_pose_tb3r:
  position: [-0.251043587923, 0.421476781368, 0.0]
  orientation: [0.0, 0.0, -0.0600887022438, 0.998193041382]
counter_pose_bread:
  position: [-3.60783815384, -0.750428497791, 0.0]
  orientation: [0.0, 0.0, 0.999335763287, -0.0364421763375]
counter_pose_drink:
  position: [-3.48697376251, -0.173366710544, 0.0]
  orientation: [0.0, 0.0, 0.998398746904, -0.0565680314445]
counter_pose_snack:
  position: [-3.62247490883, 0.39046728611, 0.0]
  orientation: [0.0, 0.0, 0.998908838216, -0.0467026009308]

fnPubPose() 函数根据当前机器人所处的服务流程，在机器人到达目标位置时设置下一个目标位置。当机器人完成服务后，所有参数将被重置。其相关说明如下：
| 项目 | 说明 |
| ---- | ---- |
| is_robot_reached_target | 机器人是否到达导航目的地 |
| is_item_available | 物品是否可用 |
| item_num_chosen_by_pad | 订单的物品编号 |
| robot_service_sequence | 机器人正在执行的流程
0 - 等待客户订单
1 - 收到客户订单后立即
2 - 去获取订购物品
3 - 装载订购物品
4 - 移动到客户位置
5 - 将物品交付给客户 |
| fnPublishVoiceFilePath() | 发布录制语音文件路径的函数 |
| ROBOT_NUMBER | 机器人编号（用户定义） |

以下是 fnPubPose() 函数的部分代码：

void fnPubPose()
{
  if (is_robot_reached_target[ROBOT_NUMBER])
  {
    if (robot_service_sequence[ROBOT_NUMBER] == 1)
    {
      fnPublishVoiceFilePath(ROBOT_NUMBER, "~/voice/voice1-2.mp3");
      robot_service_sequence[ROBOT_NUMBER] = 2;
    }
    else if (robot_service_sequence[ROBOT_NUMBER] == 2)
    {
      pubPoseStampedTb3p.publish(poseStampedCounter[item_num_chosen_by_pad[ROBOT_NUMBER]]);
      is_robot_reached_target[ROBOT_NUMBER] = false;
      robot_service_sequence[ROBOT_NUMBER] = 3;
    }
    // 其他流程判断...
  }
}

cbReceivePadOrder() 函数接收下单时使用的平板编号和订购物品的编号，以确定服务是否可用。如果服务可用，则将 robot_service_sequence 设置为 1 以启动服务。代码如下：

void cbReceivePadOrder(const turtlebot3_carrier::PadOrder padOrder)
{
  int pad_number = padOrder.pad_number;
  int item_number = padOrder.item_number;
  if (is_item_available[item_number] != 1)
  {
    ROS_INFO("Chosen item is currently unavailable");
    return;
  }
  if (robot_service_sequence[pad_number] != 0)
  {
    ROS_INFO("Your TurtleBot is currently on servicing");
    return;
  }
  if (item_num_chosen_by_pad[pad_number] != -1)
  {
    ROS_INFO("Your TurtleBot is currently on servicing");
    return;
  }
  item_num_chosen_by_pad[pad_number] = item_number;
  robot_service_sequence[pad_number] = 1; // just left from the table
  is_item_available[item_number] = 0;
}

cbCheckArrivalStatus() 函数用于检查订阅机器人的移动状态。代码的 else 块处理机器人在导航过程中遇到障碍物或无法找到路径的情况。以下是 cbCheckArrivalStatusTB3P 函数的部分代码：

void cbCheckArrivalStatusTB3P(const move_base_msgs::MoveBaseActionResult rcvMoveBaseActionResult)
{
  if (rcvMoveBaseActionResult.status.status == 3)
  {
    is_robot_reached_target[ROBOT_NUMBER_TB3P] = true;
  }
  else
  {
    // 处理异常情况...
  }
}

fnPublishVoicePath() 函数将预录制的语音文件位置作为字符串发布。要在ROS上实际播放语音，需要额外的ROS包。代码如下：

void fnPublishVoiceFilePath(int robot_num, const char* file_path)
{
  std_msgs::String str;
  str.data = file_path;
  if (robot_num == ROBOT_NUMBER_TB3P)
  {
    pubPlaySoundTb3p.publish(str);
  }
  else if (robot_num == ROBOT_NUMBER_TB3G)
  {
    pubPlaySoundTb3g.publish(str);
  }
  else if (robot_num == ROBOT_NUMBER_TB3R)
  {
    pubPlaySoundTb3r.publish(str);
  }
}

2.4 服务主节点

在这个例子中，服务主节点运行在搭载安卓系统的平板电脑上，不过也可以编程使其通过终端接收订单。以下是服务主节点的示例代码：

package org.ros.android.android_tutorial_pubsub;
import org.ros.concurrent.CancellableLoop;
import org.ros.message.MessageListener;
import org.ros.namespace.GraphName;
import org.ros.node.AbstractNodeMain;
import org.ros.node.ConnectedNode;
import org.ros.node.topic.Publisher;
import org.ros.node.topic.Subscriber;
import javax.security.auth.SubjectDomainCombiner;

public class ServicePad extends AbstractNodeMain {
  private String pub_pad_order_topic_name;
  private String sub_service_status_topic_name;
  private String pub_pad_status_topic_name;
  private int robot_num = 0;
  private int selected_item_num = -1;
  private boolean jump = false;
  private int[] item_num_chosen_by_pad = {-1, -1, -1};
  private int[] is_item_available = {1, 1, 1};
  private int[] robot_service_sequence = {0, 0, 0};
  public boolean[] button_pressed = {false, false, false};

  public ServicePad() {
    this.pub_pad_order_topic_name = "/tb3g/pad_order";
    this.sub_service_status_topic_name = "/tb3g/service_status";
    this.pub_pad_status_topic_name = "/tb3g/pad_status";
  }

  public GraphName getDefaultNodeName() {
    return GraphName.of("tb3g/pad");
  }

  public void onStart(ConnectedNode connectedNode) {
    final Publisher pub_pad_order = connectedNode.newPublisher(this.pub_pad_order_topic_name, "turtlebot3_carrier/PadOrder");
    final Publisher pub_pad_status = connectedNode.newPublisher(this.pub_pad_status_topic_name, "std_msgs/String");
    final Subscriber<turtlebot3_carrier.ServiceStatus> subscriber = connectedNode.newSubscriber(this.sub_service_status_topic_name, "turtlebot3_carrier/ServiceStatus");
    subscriber.addMessageListener(new MessageListener<turtlebot3_carrier.SerivceStatus>() {
      @Override
      public void onNewMessage(turtlebot3_carrier.SerivceStatus serviceStatus)
      {
        item_num_chosen_by_pad = serviceStatus.item_num_chosen_by_pad;
        is_item_available = serviceStatus.is_item_available;
        robot_service_sequence = serviceStatus.robot_service_sequence;
      }
    });
    connectedNode.executeCancellableLoop(new CancellableLoop() {
      protected void setup() {}
      protected void loop() throws InterruptedException
      {
        str_msgs.String padStatus = (str_msgs.String)pub_pad_status.newMessage();
        turtlebot3_carrier.PadOrder padOrder = (turtlebot3_carrier.PadOrder)pub_pad_order.newMessage();
        String str = "";
        if (button_pressed[0] || button_pressed[1] || button_pressed[2])
        {
          jump = false;
          if (button_pressed[0])
          {
            selected_item_num = 0;
            str += "Burger was selected";
            button_pressed[0] = false;
          }
          else if (button_pressed[1])
          {
            selected_item_num = 1;
            str += "Coffee was selected";
            button_pressed[1] = false;
          }
          else if (button_pressed[2])
          {
            selected_item_num = 2;
            str += "Waffle was selected";
            button_pressed[2] = false;
          }
          else
          {
            selected_item_num = -1;
            str += "Sorry, selected item is now unavailable. Please choose another item.";
          }
          if (is_item_available[selected_item_num] != 1)
          {
            str += ", but chosen item is currently unavailable.";
            jump = true;
          }
          else if (robot_service_sequence[robot_num] != 0)
          {
            str += ", but your TurtleBot is currently on servicing";
            jump = true;
          }
          else if (item_num_chosen_by_pad[robot_num] != -1)
          {
            str += ", but your TurtleBot is currently on servicing";
            jump = true;
          }
          padStatus.setData(str);
          pub_pad_status.publish(padStatus);
          if(!jump)
          {
            padOrder.pad_number = robot_num;
            padOrder.item_number = selected_item_num;
            pub_pad_order.publish(padOrder);
          }
        }
        Thread.sleep(1000L);
      }
    });
  }
}

在代码中， MainActivity 类接收并使用 ServicePad 类的实例。与一般的 MainActivity 类类似，除了与配送服务相关的部分，其他部分不再详细解释。平板电脑控制的机器人编号指定为 robot_num ，平板电脑上所选产品的编号初始化为 -1 。为避免重复订单，平板电脑在接收客户订单前必须与服务核心中存储的订单状态同步。以下是部分关键代码说明：

private int robot_num = 0;
private int selected_item_num = -1;
private int[] item_num_chosen_by_pad = {-1, -1, -1};
private int[] is_item_available = {1, 1, 1};
private int[] robot_service_sequence = {0, 0, 0};

创建 ServicePad 类的实例时，需要指定主题名称。在这个例子中，每个平板和机器人对被指定为一个组命名空间，因此需要在每个主题名称前加上命名空间中使用的名称。

public ServicePad() {
  this.pub_pad_order_topic_name = "/tb3g/pad_order";
  this.sub_service_status_topic_name = "/tb3g/service_status";
  this.pub_pad_status_topic_name = "/tb3g/pad_status";
}

指定在ROS上显示的节点名称，节点名称也应加上组命名空间。

public GraphName getDefaultNodeName() {
  return GraphName.of("tb3g/pad");
}

从服务核心，用户可以接收服务条件，如订购物品的编号、物品选择的可用性以及机器人的服务状态。

subscriber.addMessageListener(new MessageListener<turtlebot3_carrier.ServiceStatus>() {
  @Override
  public void onNewMessage(turtlebot3_carrier.ServiceStatus serviceStatus)
  {
    item_num_chosen_by_pad = serviceStatus.item_num_chosen_by_pad;
    is_item_available = serviceStatus.is_item_available;
    robot_service_sequence = serviceStatus.robot_service_sequence;
  }
});

这部分代码根据与服务核心同步的整体服务情况处理客户的订单。同样，会检查订单是否重复，如果服务可用，则发布订单。当客户在平板上选择物品时，会出现成功和不成功订单的不同示例界面。

综上所述，通过以上步骤和代码示例，我们可以搭建一个基于ROS的配送服务机器人系统，实现客户下单、机器人配送等功能。在实际应用中，还可以根据具体需求对系统进行进一步的优化和扩展。

基于ROS的配送服务机器人系统搭建（续）

3. 服务主节点订单处理逻辑分析

服务主节点的核心功能之一是处理客户的订单。在上述代码中，订单处理逻辑主要在 ConnectedNode 的 CancellableLoop 中实现。下面详细分析这部分逻辑。

3.1 订单处理流程

订单处理流程可以概括为以下几个步骤：
1. 检查按钮状态 ：检查 button_pressed 数组中是否有按钮被按下。如果有按钮被按下，则表示客户有下单操作。
2. 确定所选物品 ：根据被按下的按钮，确定客户所选的物品编号 selected_item_num ，并生成相应的提示信息 str 。
3. 检查服务可用性 ：检查所选物品是否可用（ is_item_available ），以及机器人是否正在服务（ robot_service_sequence 和 item_num_chosen_by_pad ）。如果服务不可用，则设置 jump 为 true ，并在提示信息中添加相应的错误信息。
4. 发布订单状态 ：将提示信息 str 设置到 padStatus 消息中，并通过 pub_pad_status 发布。
5. 发布订单 ：如果服务可用（ jump 为 false ），则将订单信息（平板编号 pad_number 和物品编号 item_number ）设置到 padOrder 消息中，并通过 pub_pad_order 发布。

以下是订单处理流程的mermaid流程图：

graph LR
    A[检查按钮状态] --> B{有按钮被按下?}
    B -- 是 --> C[确定所选物品]
    B -- 否 --> D[等待下一次检查]
    C --> E[检查服务可用性]
    E -- 可用 --> F[发布订单状态]
    F --> G[发布订单]
    E -- 不可用 --> H[设置错误信息]
    H --> F
    G --> D
    F --> D

3.2 代码实现细节

以下是订单处理部分的代码：

connectedNode.executeCancellableLoop(new CancellableLoop() {
    protected void setup() {}
    protected void loop() throws InterruptedException
    {
        str_msgs.String padStatus = (str_msgs.String)pub_pad_status.newMessage();
        turtlebot3_carrier.PadOrder padOrder = (turtlebot3_carrier.PadOrder)pub_pad_order.newMessage();
        String str = "";
        if (button_pressed[0] || button_pressed[1] || button_pressed[2])
        {
            jump = false;
            if (button_pressed[0])
            {
                selected_item_num = 0;
                str += "Burger was selected";
                button_pressed[0] = false;
            }
            else if (button_pressed[1])
            {
                selected_item_num = 1;
                str += "Coffee was selected";
                button_pressed[1] = false;
            }
            else if (button_pressed[2])
            {
                selected_item_num = 2;
                str += "Waffle was selected";
                button_pressed[2] = false;
            }
            else
            {
                selected_item_num = -1;
                str += "Sorry, selected item is now unavailable. Please choose another item.";
            }
            if (is_item_available[selected_item_num] != 1)
            {
                str += ", but chosen item is currently unavailable.";
                jump = true;
            }
            else if (robot_service_sequence[robot_num] != 0)
            {
                str += ", but your TurtleBot is currently on servicing";
                jump = true;
            }
            else if (item_num_chosen_by_pad[robot_num] != -1)
            {
                str += ", but your TurtleBot is currently on servicing";
                jump = true;
            }
            padStatus.setData(str);
            pub_pad_status.publish(padStatus);
            if(!jump)
            {
                padOrder.pad_number = robot_num;
                padOrder.item_number = selected_item_num;
                pub_pad_order.publish(padOrder);
            }
        }
        Thread.sleep(1000L);
    }
});

3.3 代码解释

• button_pressed 数组 ：用于记录按钮的按下状态。在实际应用中，可以通过界面交互来设置这些按钮的状态。
• selected_item_num ：记录客户所选的物品编号。根据不同的按钮按下情况，将其设置为相应的值。
• is_item_available 数组 ：记录每个物品的可用性。如果某个物品不可用，则在检查服务可用性时会拒绝订单。
• robot_service_sequence 数组 ：记录机器人的服务状态。如果机器人正在服务，则会拒绝新的订单。
• item_num_chosen_by_pad 数组 ：记录每个平板当前的订单情况。如果平板已经有未完成的订单，则会拒绝新的订单。
• jump 变量 ：用于标记服务是否可用。如果服务不可用，则跳过订单发布步骤。
• padStatus 消息 ：用于向客户反馈订单状态，包括所选物品和错误信息。
• padOrder 消息 ：用于向服务核心发送订单信息，包括平板编号和物品编号。

4. 服务核心节点与服务主节点的交互

服务核心节点和服务主节点之间的交互是整个配送服务机器人系统的关键。通过消息传递，它们可以协同工作，完成订单处理和机器人调度。

4.1 消息传递机制

服务核心节点和服务主节点之间通过ROS主题进行消息传递。主要的消息传递包括：
- 服务主节点向服务核心节点发送订单 ：服务主节点通过 /tb3g/pad_order 主题向服务核心节点发送订单信息（ PadOrder 消息）。
- 服务核心节点向服务主节点发送服务状态 ：服务核心节点通过 /tb3g/service_status 主题向服务主节点发送服务状态信息（ ServiceStatus 消息）。

以下是消息传递机制的表格总结：
| 主题名称 | 消息类型 | 发送节点 | 接收节点 | 说明 |
| ---- | ---- | ---- | ---- | ---- |
| /tb3g/pad_order | turtlebot3_carrier/PadOrder | 服务主节点 | 服务核心节点 | 客户订单信息 |
| /tb3g/service_status | turtlebot3_carrier/ServiceStatus | 服务核心节点 | 服务主节点 | 服务状态信息 |

4.2 交互流程

服务核心节点和服务主节点的交互流程可以概括为以下几个步骤：
1. 服务主节点接收客户订单 ：客户在平板上按下按钮，触发订单处理逻辑。
2. 服务主节点检查服务可用性 ：根据服务核心节点发送的服务状态信息，检查所选物品和机器人的服务状态。
3. 服务主节点发送订单 ：如果服务可用，服务主节点向服务核心节点发送订单信息。
4. 服务核心节点处理订单 ：服务核心节点接收订单信息，安排机器人执行服务，并更新服务状态。
5. 服务核心节点发送服务状态 ：服务核心节点将更新后的服务状态信息发送给服务主节点。
6. 服务主节点更新界面 ：服务主节点根据服务状态信息，更新界面显示，向客户反馈订单处理结果。

以下是交互流程的mermaid流程图：

graph LR
    A[服务主节点接收客户订单] --> B[服务主节点检查服务可用性]
    B -- 可用 --> C[服务主节点发送订单]
    B -- 不可用 --> D[服务主节点反馈错误信息]
    C --> E[服务核心节点处理订单]
    E --> F[服务核心节点更新服务状态]
    F --> G[服务核心节点发送服务状态]
    G --> H[服务主节点更新界面]
    D --> H

5. 总结与展望

通过以上对配送服务机器人系统的介绍，我们了解了系统的配置、服务核心节点和服务主节点的实现，以及它们之间的交互机制。这个系统利用ROS平台，实现了订单处理、机器人调度和服务状态反馈等功能。

在实际应用中，可以根据具体需求对系统进行进一步的优化和扩展。例如：
- 增加机器人数量 ：通过合理的命名空间和节点配置，可以轻松扩展系统，支持更多的机器人同时工作。
- 优化路径规划算法 ：采用更高效的路径规划算法，提高机器人的配送效率。
- 增加语音交互功能 ：结合语音识别和合成技术，实现更加人性化的交互方式。
- 集成库存管理系统 ：与库存管理系统集成，实时监控物品的库存情况，避免因库存不足导致的订单失败。

总之，基于ROS的配送服务机器人系统具有很大的发展潜力，可以为物流、餐饮等行业提供高效、智能的配送解决方案。