Introdução ao Baidu Apollo Cyber RT, conceitos básicos e comparação com ROS

1. Fundo

As deficiências do ROS no campo da direção autônoma:

• Incerteza de programação: cada nó é executado como um processo independente e a seqüência de operação do nó não pode ser determinada, portanto, a seqüência de programação da lógica de negócios não pode ser garantida;
• Eficiência operacional: ROS é um sistema distribuído com sobrecarga de comunicação

Em segundo lugar, a estrutura Cyber ​​RT

De baixo para cima:

    Biblioteca básica: alto desempenho, fila livre de bloqueio;
    camada de comunicação: mecanismo de publicação / assinatura, mecanismo de serviço / cliente, autodescoberta de serviço, mecanismo de comunicação adaptável (memória compartilhada, soquete, em processo);
    camada de dados: armazenamento em cache e fusão de dados . Os dados entre vários sensores precisam ser fundidos e o algoritmo pode precisar armazenar determinados dados em cache. Por exemplo, uma aplicação de simulação típica requer uma ponte de dados entre diferentes módulos de algoritmo.A camada de dados serve como uma ponte de comunicação entre os módulos, a
    camada de cálculo: modelo de cálculo, tarefas e agendamento de tarefas;

Três, processo de operação
 

    O módulo de algoritmo configura a relação lógica entre as tarefas por meio de um gráfico acíclico direcionado (DAG). Para cada algoritmo, você pode configurar a prioridade, o tempo de execução e o uso de recursos.
    Quando o sistema é iniciado, ele combina DAG, configuração de agendamento, etc., para criar tarefas correspondentes.De dentro da estrutura, é o
    agendador de co- rotina que coloca as tarefas na fila de cada processador.
    Então, a entrada de dados pelo Sensor conduz a operação de todo o sistema.

Quarto, conceitos básicos e comparação com ROS

Cinco, características

    Alto desempenho: nenhum objeto de bloqueio, corrotina, mecanismo de comunicação adaptável;
    determinismo: tarefas configuráveis ​​e agendamento de tarefas, por meio da corrotina, o agendamento é transferido do espaço do kernel para o espaço do usuário;
    modularidade: os componentes são implementados dentro da estrutura E nós, você pode completar tarefas do sistema;
    conveniência: criar e usar tarefas

Seis, amostra de mensagem do
escritor / leitor
:
 

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;
}

Leitor:

#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;
}

Serviço /
Mensagem do cliente :

syntax = "proto2";

package apollo.cyber.examples.proto;

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

Serviço / 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;
}

Sete, estrutura geral da Apollo