low_can_subscription_t* can_subscription = (low_can_subscription_t*)userdata;
if ((revents & EPOLLIN) != 0)
{
- can_message_t cm;
+ std::shared_ptr<can_message_t> cm;
utils::socketcan_bcm_t& s = can_subscription->get_socket();
- s >> cm;
+ cm = s.read_message();
// Sure we got a valid CAN message ?
- if(! cm.get_id() == 0 && ! cm.get_length() == 0)
- {push_n_notify(cm);}
+ if(! cm->get_id() == 0 && ! cm->get_length() == 0)
+ {push_n_notify(*cm);}
}
// check if error or hangup
// else monitor all standard 8 CAN OBD2 ID response.
if(bcm_msg.msg_head.can_id != OBD2_FUNCTIONAL_BROADCAST_ID)
{
- socket_ << bcm_msg;
+ socket_.write_message(bcm_msg);
if(! socket_)
return -1;
}
{
bcm_msg.msg_head.can_id = OBD2_FUNCTIONAL_RESPONSE_START + i;
- socket_ << bcm_msg;
+ socket_.write_message(bcm_msg);
if(! socket_)
return -1;
}
if(open_socket(bus_name) < 0)
{return -1;}
- socket_ << bcm_msg;
+ socket_.write_message(bcm_msg);
if(! socket_)
return -1;
bcm_msg.frames[0] = cf;
- tx_socket << bcm_msg;
+ tx_socket.write_message(bcm_msg);
if(tx_socket)
return true;
return false;
/// Read the socket to retrieve the associated CAN message. All the hard work is do into
/// convert_from_frame method and if there isn't CAN message retrieve, only BCM head struct,
/// then CAN message will be zeroed and must be handled later.
- socketcan_bcm_t& operator>>(socketcan_bcm_t& s, can_message_t& cm)
+ std::shared_ptr<can_message_t> socketcan_bcm_t::read_message()
{
- struct utils::bcm_msg msg;
+ struct bcm_msg msg;
+ std::shared_ptr<can_message_t> cm = std::make_shared<can_message_t>();
- const struct sockaddr_can& addr = s.get_tx_address();
+ const struct sockaddr_can& addr = get_tx_address();
socklen_t addrlen = sizeof(addr);
struct ifreq ifr;
- ssize_t nbytes = ::recvfrom(s.socket(), &msg, sizeof(msg), 0, (struct sockaddr*)&addr, &addrlen);
+ ssize_t nbytes = ::recvfrom(socket(), &msg, sizeof(msg), 0, (struct sockaddr*)&addr, &addrlen);
if(nbytes < 0)
{
- AFB_ERROR("Can't read the next message from socket '%d'. '%s'", s.socket(), strerror(errno));
- return s;
+ AFB_ERROR("Can't read the next message from socket '%d'. '%s'", socket(), strerror(errno));
+ return cm;
}
ifr.ifr_ifindex = addr.can_ifindex;
- if(ioctl(s.socket(), SIOCGIFNAME, &ifr) < 0)
+ if(ioctl(socket(), SIOCGIFNAME, &ifr) < 0)
{
AFB_ERROR("Can't read the interface name. '%s'", strerror(errno));
- return s;
+ return cm;
}
long unsigned int frame_size = nbytes-sizeof(struct bcm_msg_head);
AFB_DEBUG("Data available: %li bytes read. BCM head, opcode: %i, can_id: %i, nframes: %i", frame_size, msg.msg_head.opcode, msg.msg_head.can_id, msg.msg_head.nframes);
struct timeval tv;
- ioctl(s.socket(), SIOCGSTAMP, &tv);
+ ioctl(socket(), SIOCGSTAMP, &tv);
uint64_t timestamp = 1000000 * tv.tv_sec + tv.tv_usec;
- cm = can_message_t::convert_from_frame(msg.fd_frames[0] , frame_size, timestamp);
- cm.set_sub_id((int)s.socket());
+ *cm = can_message_t::convert_from_frame(msg.fd_frames[0] , frame_size, timestamp);
+ cm->set_sub_id((int)socket());
- return s;
+ return cm;
}
- socketcan_bcm_t& operator<<(socketcan_bcm_t& s, const std::vector<struct utils::bcm_msg>& vobj)
+ void socketcan_bcm_t::write_message(std::vector<std::shared_ptr<can_message_t>>& vobj)
{
for(const auto& obj : vobj)
- s << obj;
- return s;
+ write_message(obj);
}
- socketcan_bcm_t& operator<<(socketcan_bcm_t& s, const struct utils::bcm_msg& obj)
+ void socketcan_bcm_t::write_message(std::shared_ptr<can_message_t> m)
+ {
+ struct can_frame obj;
+ obj.can_id = m->get_id();
+ obj.can_dlc = m->get_length();
+ ::memcpy(obj.data, m->get_data(), CAN_MAX_DLEN);
+ if (::sendto(socket(), &obj, sizeof(&obj), 0, (const struct sockaddr*)&get_tx_address(), sizeof(get_tx_address())) < 0)
+ AFB_API_ERROR(afbBindingV3root, "Error sending : %i %s", errno, ::strerror(errno));
+ }
+
+ void socketcan_bcm_t::write_message(struct bcm_msg& obj)
{
size_t size = (obj.msg_head.flags & CAN_FD_FRAME) ?
- (size_t)((char*)&obj.fd_frames[obj.msg_head.nframes] - (char*)&obj):
- (size_t)((char*)&obj.frames[obj.msg_head.nframes] - (char*)&obj);
- if (::sendto(s.socket(), &obj, size, 0, (const struct sockaddr*)&s.get_tx_address(), sizeof(s.get_tx_address())) < 0)
+ (size_t)((char*)&obj.fd_frames[obj.msg_head.nframes] - (char*)&obj):
+ (size_t)((char*)&obj.frames[obj.msg_head.nframes] - (char*)&obj);
+ if (::sendto(socket(), &obj, size, 0, (const struct sockaddr*)&get_tx_address(), sizeof(get_tx_address())) < 0)
AFB_API_ERROR(afbBindingV3root, "Error sending : %i %s", errno, ::strerror(errno));
- return s;
}
}
using socketcan_t::socketcan_t;
virtual int open(std::string device_name);
+ virtual std::shared_ptr<can_message_t> read_message();
+ virtual void write_message(std::vector<std::shared_ptr<can_message_t>>& vobj);
+ virtual void write_message(std::shared_ptr<can_message_t> obj);
+ void write_message(struct bcm_msg& obj);
private:
int connect(const struct sockaddr* addr, socklen_t len);
};
- socketcan_bcm_t& operator>>(socketcan_bcm_t& s, can_message_t& cm);
- socketcan_bcm_t& operator<<(socketcan_bcm_t& s, const std::vector<struct bcm_msg>& obj);
- socketcan_bcm_t& operator<<(socketcan_bcm_t& s, const struct bcm_msg& obj);
}
--- /dev/null
+/*
+ * Copyright (C) 2018, 2019 "IoT.bzh"
+ * Author "Arthur Guyader" <arthur.guyader@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <net/if.h>
+#include <sys/ioctl.h>
+#include <fcntl.h>
+#include "./socketcan-j1939.hpp"
+#include "../binding/application.hpp"
+
+namespace utils
+{
+ /// @brief Connect the socket.
+ /// @return 0 if success.
+ int socketcan_j1939_t::connect(const struct sockaddr* addr, socklen_t len)
+ {
+ return socket_ != INVALID_SOCKET ? ::connect(socket_, addr, len) : 0;
+ }
+
+ /// @brief Bind the socket.
+ /// @return 0 if success.
+ int socketcan_j1939_t::bind(const struct sockaddr* addr, socklen_t len)
+ {
+ return socket_ != INVALID_SOCKET ? ::bind(socket_, addr, len) : 0;
+ }
+
+ void socketcan_j1939_t::filter(name_t name, pgn_t pgn, uint8_t addr, uint64_t name_mask, uint32_t pgn_mask, uint8_t addr_mask)
+ {
+ int filter_on = 0;
+ struct j1939_filter filter;
+ memset(&filter, 0, sizeof(filter));
+ if (name)
+ {
+ filter.name = name;
+ if(name_mask)
+ {
+ filter.name_mask = name_mask;
+ } else
+ {
+ filter.name_mask = ~0ULL;
+ }
+ ++filter_on;
+ }
+
+ if (addr < 0xff)
+ {
+ filter.addr = addr;
+ if(addr_mask)
+ {
+ filter.addr_mask = addr_mask;
+ } else
+ {
+ filter.addr_mask = ~0;
+ }
+ ++filter_on;
+ }
+ if (pgn <= J1939_PGN_MAX)
+ {
+ filter.pgn = pgn;
+ if(pgn_mask)
+ {
+ filter.pgn_mask = pgn_mask;
+ } else
+ {
+ filter.pgn_mask = ~0;
+ }
+ ++filter_on;
+ }
+ if(filter_on){
+ setopt(SOL_CAN_J1939, SO_J1939_FILTER, &filter, sizeof(filter));
+ }
+ }
+
+ int socketcan_j1939_t::open(std::string device_name)
+ {
+ return open(device_name,0,0,0);
+ }
+
+ int socketcan_j1939_t::open(std::string device_name, name_t name, pgn_t pgn, uint8_t addr)
+ {
+
+ struct ifreq ifr;
+ socket_ = socketcan_t::open(PF_CAN, SOCK_DGRAM, CAN_J1939);
+
+ // Attempts to open a socket to CAN bus
+ ::strcpy(ifr.ifr_name, device_name.c_str());
+ AFB_DEBUG("ifr_name is : %s", ifr.ifr_name);
+ if(::ioctl(socket_, SIOCGIFINDEX, &ifr) < 0)
+ {
+ AFB_ERROR("ioctl failed. Error was : %s", strerror(errno));
+ close();
+ }
+ else
+ {
+ tx_address_.can_family = AF_CAN;
+ tx_address_.can_ifindex = ifr.ifr_ifindex;
+
+ if(addr <= 0 || addr >= UINT8_MAX )
+ {
+ tx_address_.can_addr.j1939.addr = J1939_NO_ADDR;
+ }
+ else
+ {
+ tx_address_.can_addr.j1939.addr = addr;
+ }
+
+ if(name <= 0 || name >= UINT64_MAX )
+ {
+ tx_address_.can_addr.j1939.name = J1939_NO_NAME;
+ }
+ else
+ {
+ tx_address_.can_addr.j1939.name = name;
+ }
+
+ if(pgn <= 0 || pgn > J1939_PGN_MAX)
+ {
+ tx_address_.can_addr.j1939.pgn = J1939_NO_PGN;
+ }
+ else
+ {
+ tx_address_.can_addr.j1939.pgn = pgn;
+ }
+
+ if(bind((struct sockaddr *)&tx_address_, sizeof(tx_address_)) < 0)
+ {
+ AFB_ERROR("Bind failed. %s", strerror(errno));
+ close();
+ }
+ else
+ {
+ int promisc = 1; // 0 = disabled (default), 1 = enabled
+ setopt(SOL_CAN_J1939, SO_J1939_PROMISC, &promisc, sizeof(promisc));
+ int recv_own_msgs = 1; // 0 = disabled (default), 1 = enabled
+ setopt(SOL_CAN_J1939, SO_J1939_RECV_OWN, &recv_own_msgs, sizeof(recv_own_msgs));
+ if(tx_address_.can_addr.j1939.pgn != J1939_NO_PGN)
+ {
+ filter(J1939_NO_NAME,tx_address_.can_addr.j1939.pgn,J1939_NO_ADDR);
+ }
+ }
+ }
+ return socket_;
+ }
+
+ std::shared_ptr<message_t> socketcan_j1939_t::read_message()
+ {
+ std::shared_ptr<j1939_message_t> jm = std::make_shared<j1939_message_t>();
+ uint8_t data[128] = {0};
+
+ struct sockaddr_can addr;
+ socklen_t addrlen = sizeof(addr);
+ struct ifreq ifr;
+
+ ssize_t nbytes = ::recvfrom(socket(), &data, sizeof(data), 0, (struct sockaddr*)&addr, &addrlen);
+ ifr.ifr_ifindex = get_tx_address().can_ifindex;
+ ioctl(socket(), SIOCGIFNAME, &ifr);
+
+ AFB_DEBUG("Data available: %i bytes read", (int)nbytes);
+ /*AFB_DEBUG("read: Found on bus %s:\n id: %X, length: %X, data %02X%02X%02X%02X%02X%02X%02X%02X", ifr.ifr_name, frame.can_id, frame.len,
+ data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);*/
+
+ struct timeval tv;
+ ioctl(socket(), SIOCGSTAMP, &tv);
+ uint64_t timestamp = 1000000 * tv.tv_sec + tv.tv_usec;
+ jm = j1939_message_t::convert_from_addr(addr, data , nbytes, timestamp);
+ jm->set_sub_id((int)socket());
+ return jm;
+ }
+
+
+ void socketcan_j1939_t::write_message(std::vector<std::shared_ptr<can_message_t>>& vobj)
+ {
+ AFB_WARNING("Not implemented");
+ }
+
+ void socketcan_j1939_t::write_message(std::shared_ptr<can_message_t> cm)
+ {
+ AFB_WARNING("Not implemented");
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (C) 2018, 2019 "IoT.bzh"
+ * Author "Arthur Guyader" <arthur.guyader@iot.bzh>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <linux/can/j1939.h>
+
+#include "./socketcan.hpp"
+#include "../can/message/j1939-message.hpp"
+
+namespace utils
+{
+
+ class socketcan_j1939_t : public socketcan_t
+ {
+ public:
+ using socketcan_t::socketcan_t;
+ virtual int open(std::string device_name);
+ int open(std::string device_name, name_t name, pgn_t pgn, uint8_t addr);
+ virtual std::shared_ptr<message_t> read_message();
+ virtual void write_message(std::shared_ptr<message_t> obj);
+ virtual void write_message(std::vector<std::shared_ptr<message_t>>& vobj);
+
+ private:
+ int connect(const struct sockaddr* addr, socklen_t len);
+ int bind(const struct sockaddr* addr, socklen_t len);
+ void filter(name_t name, pgn_t pgn, uint8_t addr, uint64_t name_mask=0, uint32_t pgn_mask=0, uint8_t addr_mask=0);
+ };
+}
return socket_;
}
- socketcan_raw_t& operator>>(socketcan_raw_t& s, can_message_t& cm)
+ std::shared_ptr<message_t> socketcan_raw_t::read_message()
{
+ std::shared_ptr<can_message_t> cm = std::make_shared<can_message_t>();
struct canfd_frame frame;
- const struct sockaddr_can& addr = s.get_tx_address();
+ const struct sockaddr_can& addr = get_tx_address();
socklen_t addrlen = sizeof(addr);
struct ifreq ifr;
- ssize_t nbytes = ::recvfrom(s.socket(), &frame, sizeof(frame), 0, (struct sockaddr*)&addr, &addrlen);
+ ssize_t nbytes = ::recvfrom(socket(), &frame, sizeof(frame), 0, (struct sockaddr*)&addr, &addrlen);
ifr.ifr_ifindex = addr.can_ifindex;
- ioctl(s.socket(), SIOCGIFNAME, &ifr);
+ ioctl(socket(), SIOCGIFNAME, &ifr);
AFB_DEBUG("Data available: %i bytes read", (int)nbytes);
AFB_DEBUG("read: Found on bus %s:\n id: %X, length: %X, data %02X%02X%02X%02X%02X%02X%02X%02X", ifr.ifr_name, frame.can_id, frame.len,
frame.data[0], frame.data[1], frame.data[2], frame.data[3], frame.data[4], frame.data[5], frame.data[6], frame.data[7]);
struct timeval tv;
- ioctl(s.socket(), SIOCGSTAMP, &tv);
+ ioctl(socket(), SIOCGSTAMP, &tv);
uint64_t timestamp = 1000000 * tv.tv_sec + tv.tv_usec;
cm = ::can_message_t::convert_from_frame(frame , nbytes, timestamp);
- return s;
+ return cm;
+ }
+
+ void socketcan_raw_t::write_message(std::vector<std::shared_ptr<message_t>>& vobj)
+ {
+ AFB_WARNING("Not implemented");
+ }
+
+ void socketcan_raw_t::write_message(std::shared_ptr<message_t> cm)
+ {
+ AFB_WARNING("Not implemented");
}
}
#pragma once
#include "socketcan.hpp"
-#include "../can/can-message.hpp"
+#include "../can/message/can-message.hpp"
namespace utils
{
public:
using socketcan_t::socketcan_t;
virtual int open(std::string device_name);
+ virtual std::shared_ptr<message_t> read_message();
+ virtual void write_message(std::shared_ptr<message_t> cm);
+ virtual void write_message(std::vector<std::shared_ptr<message_t>>& vobj);
private:
int bind(const struct sockaddr* addr, socklen_t len);
};
- socketcan_raw_t& operator>>(socketcan_raw_t& s, can_message_t& cm);
}
#include <string.h>
#include "../binding/low-can-hat.hpp"
+#include "../can/can-message.hpp"
#define INVALID_SOCKET -1
namespace utils
{
+
class socketcan_t
{
public:
int socket() const;
virtual int open(std::string device_name) = 0;
int setopt(int level, int optname, const void* optval, socklen_t optlen);
- int close();
+ virtual int close();
+ virtual std::shared_ptr<can_message_t> read_message() = 0;
+ virtual void write_message(std::shared_ptr<can_message_t> obj) = 0;
+ virtual void write_message(std::vector<std::shared_ptr<can_message_t>>& vobj) = 0;
protected:
int socket_;
struct sockaddr_can tx_address_;
-
int open(int domain, int type, int protocol);
};
- template <typename T>
- socketcan_t& operator<<(socketcan_t& s, const std::vector<T>& vobj)
- {
- for(const auto& obj : vobj)
- s << obj;
- return s;
- }
- template <typename T>
- socketcan_t& operator<<(socketcan_t& s, const T& obj)
- {
- if (::sendto(s.socket(), &obj, sizeof(obj), 0, (const struct sockaddr*)&s.get_tx_address(), sizeof(s.get_tx_address())) < 0)
- AFB_API_ERROR(afbBindingV3root, "Error sending : %i %s", errno, ::strerror(errno));
- return s;
- }
}
Code Review / apps / agl-service-can-low-level.git / commitdiff