13

我正在考虑使用Boost Asio从Socket CAN读取数据。在linux/can.h中没有什么花哨的东西，设备应该像环回接口一样工作，并与原始套接字一起使用。

查看basic_raw_socket界面似乎我可以使用 basic_raw_socket::assign来分配使用创建的本机套接字

socket( PF_CAN, SOCK_RAW, CAN_RAW );

这是我到目前为止所拥有的

namespace can {
       class CanSocket {
       public:
               typedef boost::asio::ip::basic_endpoint<CanSocket> endpoint;
               typedef boost::asio::ip::basic_resolver_query<CanSocket> resolver_query;
               typedef boost::asio::ip::basic_resolver_iterator<CanSocket> resolver_iterator;
               typedef boost::asio::basic_raw_socket<CanSocket> socket;
               typedef boost::asio::ip::basic_resolver<CanSocket> resolver;

               CanSocket()
                       : _protocol( CAN_RAW )
                       , _family( PF_CAN )
               {
               }

               static CanSocket v4()
               {
                       return CanSocket();
               }
               static CanSocket v6();
               int type() const;
               int protocol() const;
               int family() const;

               friend bool operator==(const CanSocket& p1, const CanSocket& p2)
               {
                       return p1._protocol != p2._protocol || p1._family != p2._family;
               }
               friend bool operator!=(const CanSocket& p1, const CanSocket& p2)
               {
                       return p1._protocol == p2._protocol || p1._family == p2._family;
               }

       private:
               int _protocol;
               int _family;
};
}

这就是我在我的应用程序中使用它的方式

   boost::asio::io_service ioserv;

   CanSocket::socket s( ioserv );

   int sock = socket( PF_CAN, SOCK_RAW, CAN_RAW );

   s.assign(CanSocket::v4(), sock);

   struct ifreq ifr;
   strcpy(ifr.ifr_name, "vcan0");
   ioctl(sock, SIOCGIFINDEX, &ifr); /* ifr.ifr_ifindex gets filled
                                 * with that device's index */

   /* Select that CAN interface, and bind the socket to it. */

   /* this should be the endpoint */
   struct sockaddr_can addr;
   addr.can_family = AF_CAN;
   addr.can_ifindex = ifr.ifr_ifindex;

   /* s.bind (....) */
   bind( sock, (struct sockaddr*)&addr, sizeof(addr) );

我不太明白的是如何绑定 s到本地端点？不涉及 IP 或端口。

除了端点之外，还有什么其他应该实现的吗？

4

2 回答 2

8

这是工作示例，在此线程的帮助下组装

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <iostream>

#include <net/if.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>

#include <linux/can.h>
#include <linux/can/raw.h>

#include <boost/asio.hpp>
#include <boost/bind.hpp>

void data_send(void) {
  std::cout << "omg sent" << std::endl;
}

void data_rec(struct can_frame &rec_frame,
              boost::asio::posix::basic_stream_descriptor<> &stream) {
  std::cout << std::hex << rec_frame.can_id << "  ";
  for (int i = 0; i < rec_frame.can_dlc; i++) {
    std::cout << std::hex << int(rec_frame.data[i]) << " ";
  }
  std::cout << std::dec << std::endl;
  stream.async_read_some(
      boost::asio::buffer(&rec_frame, sizeof(rec_frame)),
      boost::bind(data_rec, boost::ref(rec_frame), boost::ref(stream)));
}

int main(void) {
  struct sockaddr_can addr;
  struct can_frame frame;
  struct can_frame rec_frame;
  struct ifreq ifr;

  int natsock = socket(PF_CAN, SOCK_RAW, CAN_RAW);

  strcpy(ifr.ifr_name, "vcan0");
  ioctl(natsock, SIOCGIFINDEX, &ifr);

  addr.can_family = AF_CAN;
  addr.can_ifindex = ifr.ifr_ifindex;
  if (bind(natsock, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
    perror("Error in socket bind");
    return -2;
  }

  frame.can_id = 0x123;
  frame.can_dlc = 2;
  frame.data[0] = 0x11;
  frame.data[1] = 0x23;

  boost::asio::io_service ios;
  boost::asio::posix::basic_stream_descriptor<> stream(ios);
  stream.assign(natsock);

  stream.async_write_some(boost::asio::buffer(&frame, sizeof(frame)),
                          boost::bind(data_send));
  stream.async_read_some(
      boost::asio::buffer(&rec_frame, sizeof(rec_frame)),
      boost::bind(data_rec, boost::ref(rec_frame), boost::ref(stream)));
  ios.run();
}
于 2013-11-24T22:58:20.317 回答
5

解决方案是使用posix::stream_descriptor.

只需打开本机套接字，绑定然后使用posix::basic_stream_descriptor::assign.

于 2012-05-11T00:16:15.667 回答