can_client_tool.cc 文件参考

#include <cstdint>
#include <iostream>
#include <memory>
#include <thread>
#include "cyber/common/file.h"
#include "cyber/common/log.h"
#include "cyber/time/time.h"
#include "gflags/gflags.h"
#include "modules/common_msgs/basic_msgs/error_code.pb.h"
#include "modules/common/util/factory.h"
#include "modules/drivers/canbus/can_client/can_client.h"
#include "modules/drivers/canbus/can_client/can_client_factory.h"
#include "modules/drivers/canbus/common/byte.h"
#include "modules/common_msgs/drivers_msgs/can_card_parameter.pb.h"

can_client_tool.cc 的引用(Include)关系图:

浏览源代码.

类
struct	apollo::drivers::canbus::TestCanParam
class	apollo::drivers::canbus::CanAgent

命名空间
namespace	apollo
	class register implement
namespace	apollo::drivers
	apollo::drivers
namespace	apollo::drivers::canbus
	apollo::drivers::canbus

函数
	DEFINE_bool (only_one_send, false, "only send test.")
	DEFINE_string (can_client_conf_file_a, "modules/canbus/conf/can_client_conf_a.pb.txt", "can client conf for client a")
	DEFINE_string (can_client_conf_file_b, "modules/canbus/conf/can_client_conf_b.pb.txt", "can client conf for client b")
	DEFINE_int64 (agent_mutual_send_frames, 1000, "Every agent send frame num")
int	main (int32_t argc, char **argv)

变量
const int32_t	MAX_CAN_SEND_FRAME_LEN = 1
const int32_t	MAX_CAN_RECV_FRAME_LEN = 10

函数说明

DEFINE_bool()

DEFINE_bool	(	only_one_send	,
		false	,
		"only send test."
	)

DEFINE_int64()

DEFINE_int64	(	agent_mutual_send_frames	,
		1000	,
		"Every agent send frame num"
	)

DEFINE_string() [1/2]

DEFINE_string	(	can_client_conf_file_a	,
		"modules/canbus/conf/can_client_conf_a.pb.txt"	,
		"can client conf for client a"
	)

DEFINE_string() [2/2]

DEFINE_string	(	can_client_conf_file_b	,
		"modules/canbus/conf/can_client_conf_b.pb.txt"	,
		"can client conf for client b"
	)

main()

int main	(	int32_t	argc,
		char **	argv
	)

在文件 can_client_tool.cc 第 247 行定义.

                                    {
  google::InitGoogleLogging(argv[0]);
  google::ParseCommandLineFlags(&argc, &argv, true);
 
  using apollo::common::ErrorCode;
  using apollo::drivers::canbus::CanAgent;
  using apollo::drivers::canbus::CANCardParameter;
  using apollo::drivers::canbus::CanClient;
  using apollo::drivers::canbus::CanClientFactory;
  using apollo::drivers::canbus::TestCanParam;
  CANCardParameter can_client_conf_a;
  std::shared_ptr<TestCanParam> param_ptr_a(new TestCanParam());
  std::shared_ptr<TestCanParam> param_ptr_b(new TestCanParam());
 
  auto can_client_factory = CanClientFactory::Instance();
  can_client_factory->RegisterCanClients();
 
  if (!apollo::cyber::common::GetProtoFromFile(FLAGS_can_client_conf_file_a,
                                               &can_client_conf_a)) {
    AERROR << "Unable to load canbus conf file: "
           << FLAGS_can_client_conf_file_a;
    return -1;
  }
  AINFO << "Conf file is loaded: " << FLAGS_can_client_conf_file_a;
  AINFO << can_client_conf_a.ShortDebugString();
  auto client_a = can_client_factory->CreateObject(can_client_conf_a.brand());
  if (!client_a || !client_a->Init(can_client_conf_a) ||
      client_a->Start() != ErrorCode::OK) {
    AERROR << "Create can client a failed.";
    return -1;
  }
  param_ptr_a->can_client = client_a.get();
  param_ptr_a->is_first_agent = true;
  param_ptr_a->conf = can_client_conf_a;
 
  CANCardParameter can_client_conf_b;
  std::unique_ptr<CanClient> client_b;
  if (!FLAGS_only_one_send) {
    if (!apollo::cyber::common::GetProtoFromFile(FLAGS_can_client_conf_file_b,
                                                 &can_client_conf_b)) {
      AERROR << "Unable to load canbus conf file: "
             << FLAGS_can_client_conf_file_b;
      return -1;
    }
    AINFO << "Conf file is loaded: " << FLAGS_can_client_conf_file_b;
    AINFO << can_client_conf_b.ShortDebugString();
    client_b = can_client_factory->CreateObject(can_client_conf_b.brand());
    if (!client_b || !client_b->Init(can_client_conf_b) ||
        client_b->Start() != ErrorCode::OK) {
      AERROR << "Create can client b failed.";
      return -1;
    }
    param_ptr_b->can_client = client_b.get();
    param_ptr_b->conf = can_client_conf_b;
  }
 
  CanAgent agent_a(param_ptr_a.get());
  CanAgent agent_b(param_ptr_b.get());
  agent_a.AddOtherAgent(&agent_b);
  agent_b.AddOtherAgent(&agent_a);
  if (!agent_a.Start()) {
    AERROR << "Agent a start failed.";
    return -1;
  }
  if (FLAGS_only_one_send) {
    agent_b.is_receiving(true);
    agent_b.is_sending_finish(true);
  } else {
    if (!agent_b.Start()) {
      AERROR << "Agent b start failed.";
      return -1;
    }
  }
 
  agent_a.WaitForFinish();
  if (!FLAGS_only_one_send) {
    agent_b.WaitForFinish();
  }
  param_ptr_a->print();
  if (!FLAGS_only_one_send) {
    param_ptr_b->print();
  }
 
  return 0;
}

变量说明

MAX_CAN_RECV_FRAME_LEN

const int32_t MAX_CAN_RECV_FRAME_LEN = 10

在文件 can_client_tool.cc 第 43 行定义.

MAX_CAN_SEND_FRAME_LEN

const int32_t MAX_CAN_SEND_FRAME_LEN = 1

在文件 can_client_tool.cc 第 42 行定义.