Introducción a Baidu Apollo Cyber RT, conceptos básicos y comparación con ROS

1. Antecedentes

Las deficiencias de ROS en el campo de la conducción autónoma:

Incertidumbre de la programación: cada nodo se ejecuta como un proceso independiente y no se puede determinar la secuencia de operación del nodo, por lo que no se puede garantizar la secuencia de programación de la lógica empresarial;
Eficiencia operativa: ROS es un sistema distribuido con sobrecarga de comunicación

En segundo lugar, el marco Cyber RT

De abajo a arriba:

    Biblioteca básica: alto rendimiento, cola sin bloqueos;
    capa de comunicación: mecanismo de publicación / suscripción, mecanismo de servicio / cliente, autodescubrimiento del servicio, mecanismo de comunicación adaptable (memoria compartida, socket, en proceso);
    capa de datos: almacenamiento en caché y fusión de datos . Los datos entre varios sensores deben fusionarse y el algoritmo puede necesitar almacenar en caché ciertos datos. Por ejemplo, una aplicación de simulación típica requiere un puente de datos entre diferentes módulos de algoritmos, la capa de datos sirve como puente de comunicación entre los módulos, la
    capa de cálculo: modelo de cálculo, tareas y programación de tareas;

Tres, proceso de operación

    El módulo de algoritmo configura la relación lógica entre tareas a través de un gráfico acíclico dirigido (DAG). Para cada algoritmo, puede configurar la prioridad, el tiempo de ejecución y el uso de recursos.
    Cuando el sistema se inicia, combina DAG, configuración de programación, etc., para crear las tareas correspondientes Desde el interior del marco, es el
    programador de rutina el que pone las tareas en la cola de cada procesador.
    Luego, la entrada de datos por el sensor impulsa el funcionamiento de todo el sistema.

Cuarto, conceptos básicos y comparación con ROS

Cinco, características

    Alto rendimiento: sin objeto de bloqueo, corrutina, mecanismo de comunicación adaptativo;
    determinismo: tareas configurables y programación de tareas, a través de la corrutina, la programación se transfiere del espacio del kernel al espacio del usuario;
    modularidad: los componentes se implementan dentro del marco y los nodos, usted puede completar tareas del sistema;
    conveniencia: crear y usar tareas

Seis, mensaje de muestra del
escritor / lector
:

syntax = "proto2";
package apollo.cyber.examples.proto;
message Chatter {
    optional uint64 timestamp = 1;
    optional uint64 lidar_timestamp = 2;
    optional uint64 seq = 3;
    optional bytes content = 4;
};

Escritor:

#include "cyber/cyber.h"
#include "cyber/examples/proto/examples.pb.h"
#include "cyber/time/rate.h"
#include "cyber/time/time.h"

using apollo::cyber::Rate;
using apollo::cyber::Time;
using apollo::cyber::examples::proto::Chatter;

int main(int argc, char *argv[]) {
  // init cyber framework
  apollo::cyber::Init(argv[0]);
  // create talker node
  auto talker_node = apollo::cyber::CreateNode("talker");
  // create talker
  auto talker = talker_node->CreateWriter<Chatter>("channel/chatter");
  Rate rate(1.0);
  while (apollo::cyber::OK()) {
    static uint64_t seq = 0;
    auto msg = std::make_shared<Chatter>();
    msg->set_timestamp(Time::Now().ToNanosecond());
    msg->set_lidar_timestamp(Time::Now().ToNanosecond());
    msg->set_seq(seq++);
    msg->set_content("Hello, apollo!");
    talker->Write(msg);
    AINFO << "talker sent a message!";
    rate.Sleep();
  }
  return 0;
}

Lector:

#include "cyber/cyber.h"
#include "cyber/examples/proto/examples.pb.h"

void MessageCallback(
    const std::shared_ptr<apollo::cyber::examples::proto::Chatter>& msg) {
  AINFO << "Received message seq-> " << msg->seq();
  AINFO << "msgcontent->" << msg->content();
}

int main(int argc, char* argv[]) {
  // init cyber framework
  apollo::cyber::Init(argv[0]);
  // create listener node
  auto listener_node = apollo::cyber::CreateNode("listener");
  // create listener
  auto listener =
      listener_node->CreateReader<apollo::cyber::examples::proto::Chatter>(
          "channel/chatter", MessageCallback);
  apollo::cyber::WaitForShutdown();
  return 0;
}

Mensaje de servicio / cliente :

syntax = "proto2";

package apollo.cyber.examples.proto;

message Driver {
    optional string content = 1;
    optional uint64 msg_id = 2;
    optional uint64 timestamp = 3;
};

Servicio al cliente:

#include "cyber/cyber.h"
#include "cyber/examples/proto/examples.pb.h"

using apollo::cyber::examples::proto::Driver;

int main(int argc, char* argv[]) {
  apollo::cyber::Init(argv[0]);
  std::shared_ptr<apollo::cyber::Node> node(
      apollo::cyber::CreateNode("start_node"));
  auto server = node->CreateService<Driver, Driver>(
      "test_server", [](const std::shared_ptr<Driver>& request,
                        std::shared_ptr<Driver>& response) {
        AINFO << "server: i am driver server";
        static uint64_t id = 0;
        ++id;
        response->set_msg_id(id);
        response->set_timestamp(0);
      });
  auto client = node->CreateClient<Driver, Driver>("test_server");
  auto driver_msg = std::make_shared<Driver>();
  driver_msg->set_msg_id(0);
  driver_msg->set_timestamp(0);
  while (apollo::cyber::OK()) {
    auto res = client->SendRequest(driver_msg);
    if (res != nullptr) {
      AINFO << "client: responese: " << res->ShortDebugString();
    } else {
      AINFO << "client: service may not ready.";
    }
    sleep(1);
  }

  apollo::cyber::WaitForShutdown();
  return 0;
}

Siete, marco general de Apolo