apollo::drivers::canbus::CanAgent类 参考

apollo::drivers::canbus::CanAgent 的协作图:

Public 成员函数
	CanAgent (TestCanParam *param_ptr)
TestCanParam *	param_ptr ()
CanAgent *	other_agent ()
bool	Start ()
void	SendThreadFunc ()
void	AddOtherAgent (CanAgent *agent)
bool	is_receiving () const
void	is_receiving (bool val)
bool	is_sending_finish () const
void	is_sending_finish (bool val)
void	RecvThreadFunc ()
void	WaitForFinish ()

详细描述

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

构造及析构函数说明

CanAgent()

apollo::drivers::canbus::CanAgent::CanAgent ( TestCanParam *  param_ptr )

inlineexplicit

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

: param_ptr_(param_ptr) {}

成员函数说明

AddOtherAgent()

void apollo::drivers::canbus::CanAgent::AddOtherAgent ( CanAgent *  agent )

inline

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

{ other_agent_ = agent; }

is_receiving() [1/2]

bool apollo::drivers::canbus::CanAgent::is_receiving ( ) const

inline

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

{ return is_receiving_; }

is_receiving() [2/2]

void apollo::drivers::canbus::CanAgent::is_receiving ( bool  val )

inline

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

{ is_receiving_ = val; }

is_sending_finish() [1/2]

bool apollo::drivers::canbus::CanAgent::is_sending_finish ( ) const

inline

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

{ return is_sending_finish_; }

is_sending_finish() [2/2]

void apollo::drivers::canbus::CanAgent::is_sending_finish ( bool  val )

inline

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

{ is_sending_finish_ = val; }

other_agent()

CanAgent * apollo::drivers::canbus::CanAgent::other_agent ( )

inline

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

{ return other_agent_; }

param_ptr()

TestCanParam * apollo::drivers::canbus::CanAgent::param_ptr ( )

inline

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

{ return param_ptr_; }

RecvThreadFunc()

void apollo::drivers::canbus::CanAgent::RecvThreadFunc ( )

inline

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

                        {
    using common::ErrorCode;
    AINFO << "Receive thread starting...";
    TestCanParam *param = param_ptr();
    CanClient *client = param->can_client;
    int64_t start = 0;
    std::vector<CanFrame> buf;
 
    bool first = true;
    while (!other_agent()->is_sending_finish()) {
      is_receiving(true);
      int32_t len = MAX_CAN_RECV_FRAME_LEN;
      ErrorCode ret = client->Receive(&buf, &len);
      if (len == 0) {
        AINFO << "recv frame:0";
        continue;
      }
      if (first) {
        start = Time::Now().ToMicrosecond();
        first = false;
      }
      if (ret != ErrorCode::OK || len == 0) {
        // AINFO << "channel:" << param->conf.channel_id()
        //      << ", recv frame:failed, code:" << ret;
        AINFO << "recv error:" << ret;
        continue;
      }
      for (int32_t i = 0; i < len; ++i) {
        param->recv_cnt = param->recv_cnt + 1;
        AINFO << "recv_frame#" << buf[i].CanFrameString()
              << " conf:" << param->conf.ShortDebugString()
              << ",recv_cnt: " << param->recv_cnt;
      }
    }
    int64_t end = Time::Now().ToMicrosecond();
    param->recv_time = static_cast<int32_t>(end - start);
    AINFO << "Recv thread stopping..., conf:" << param->conf.ShortDebugString();
    return;
  }

SendThreadFunc()

void apollo::drivers::canbus::CanAgent::SendThreadFunc ( )

inline

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

                        {
    using common::ErrorCode;
    AINFO << "Send thread starting...";
    TestCanParam *param = param_ptr();
    CanClient *client = param->can_client;
    std::vector<CanFrame> frames;
    frames.resize(MAX_CAN_SEND_FRAME_LEN);
 
    int32_t count = 0;
    int32_t start_id = 0;
    int32_t end_id = 0;
    int32_t id = 0;
    if (param->is_first_agent) {
      start_id = 1;
      end_id = 128;
    } else {
      start_id = 129;
      end_id = start_id + 127;
    }
    id = start_id;
    int32_t send_id = id;
    AINFO << "port:" << param->conf.ShortDebugString()
          << ", start_id:" << start_id << ", end_id:" << end_id;
 
    // wait for other agent receiving is ok.
    while (!other_agent()->is_receiving()) {
      std::this_thread::yield();
    }
    int64_t start = Time::Now().ToMicrosecond();
    while (true) {
      // param->print();
      if (count >= FLAGS_agent_mutual_send_frames) {
        break;
      }
      for (int32_t i = 0; i < MAX_CAN_SEND_FRAME_LEN; ++i) {
        // frames[i].id = id_count & 0x3FF;
        send_id = id;
        frames[i].id = id;
        frames[i].len = 8;
        frames[i].data[7] = static_cast<uint8_t>(count % 256);
        for (uint8_t j = 0; j < 7; ++j) {
          frames[i].data[j] = j;
        }
        ++count;
        ++id;
        if (id > end_id) {
          id = start_id;
        }
      }
      int32_t frame_num = MAX_CAN_SEND_FRAME_LEN;
      if (client->Send(frames, &frame_num) != ErrorCode::OK) {
        param->send_err_cnt += MAX_CAN_SEND_FRAME_LEN;
        AERROR << "send_thread send msg failed!, id:" << send_id
               << ", conf:" << param->conf.ShortDebugString();
      } else {
        param->send_cnt += frame_num;
        param->send_lost_cnt += MAX_CAN_SEND_FRAME_LEN - frame_num;
        AINFO << "send_frames: " << frame_num << "send_frame#"
              << frames[0].CanFrameString()
              << " send lost:" << MAX_CAN_SEND_FRAME_LEN - frame_num
              << ", conf:" << param->conf.ShortDebugString();
      }
    }
    int64_t end = Time::Now().ToMicrosecond();
    param->send_time = static_cast<int32_t>(end - start);
    // In case for finish too quick to receiver miss some msg
    sleep(2);
    AINFO << "Send thread stopping..." << param->conf.ShortDebugString();
    is_sending_finish(true);
    return;
  }

Start()

bool apollo::drivers::canbus::CanAgent::Start ( )

inline

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

               {
    thread_recv_.reset(new std::thread([this] { RecvThreadFunc(); }));
    if (thread_recv_ == nullptr) {
      AERROR << "Unable to create recv thread.";
      return false;
    }
    thread_send_.reset(new std::thread([this] { SendThreadFunc(); }));
    if (thread_send_ == nullptr) {
      AERROR << "Unable to create send thread.";
      return false;
    }
    return true;
  }

WaitForFinish()

void apollo::drivers::canbus::CanAgent::WaitForFinish ( )

inline

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

                       {
    if (thread_send_ != nullptr && thread_send_->joinable()) {
      thread_send_->join();
      thread_send_.reset();
      AINFO << "Send thread stopped. conf:"
            << param_ptr_->conf.ShortDebugString();
    }
    if (thread_recv_ != nullptr && thread_recv_->joinable()) {
      thread_recv_->join();
      thread_recv_.reset();
      AINFO << "Recv thread stopped. conf:"
            << param_ptr_->conf.ShortDebugString();
    }
  }

---

该类的文档由以下文件生成:

• modules/drivers/canbus/can_client/can_client_tool.cc