#include "application.hpp"
#include "canutil/write.h"
#include "../utils/socketcan-bcm.hpp"
+#include "../can/can-encoder.hpp"
+
+#ifdef USE_FEATURE_ISOTP
+#include "../utils/socketcan-isotp.hpp"
+#endif
+
#ifdef USE_FEATURE_J1939
#include "../utils/socketcan-j1939/socketcan-j1939-data.hpp"
#endif
return event_filter_.max;
}
+canid_t low_can_subscription_t::get_rx_id() const
+{
+ return event_filter_.rx_id;
+}
+
+canid_t low_can_subscription_t::get_tx_id() const
+{
+ return event_filter_.tx_id;
+}
+
std::shared_ptr<utils::socketcan_t> low_can_subscription_t::get_socket()
{
return socket_;
event_filter_.max = max;
}
+void low_can_subscription_t::set_rx_id(canid_t rx_id)
+{
+ event_filter_.rx_id = rx_id;
+}
+
+void low_can_subscription_t::set_tx_id(canid_t tx_id)
+{
+ event_filter_.tx_id = tx_id;
+}
+
void low_can_subscription_t::set_index(int index)
{
index_ = index;
}
+void low_can_subscription_t::set_signal(std::shared_ptr<signal_t> signal)
+{
+ signal_ = signal;
+}
+
+
/// @brief Based upon which object is a subscribed CAN signal or diagnostic message
/// it will open the socket with the required CAN bus device name.
///
/// @return INVALID_SOCKET on failure, else positive integer
-int low_can_subscription_t::open_socket(low_can_subscription_t &subscription, const std::string& bus_name, socket_type type)
+int low_can_subscription_t::open_socket(low_can_subscription_t &subscription, const std::string& bus_name, uint32_t flags)
{
int ret = -1;
if(! subscription.socket_)
{
- switch (type)
- {
- case socket_type::BCM:
+ if(flags&BCM_PROTOCOL)
{
if( subscription.signal_ != nullptr)
{
ret = subscription.socket_->open(bus_name);
}
subscription.index_ = (int)subscription.socket_->socket();
- break;
}
+#ifdef USE_FEATURE_ISOTP
+ else if(flags&ISOTP_PROTOCOL)
+ {
+ if(subscription.signal_ != nullptr)
+ {
+ canid_t rx = NO_CAN_ID;
+ canid_t tx = NO_CAN_ID;
+ if(flags&ISOTP_SEND)
+ {
+ rx = subscription.get_rx_id();
+ tx = subscription.signal_->get_message()->get_id();
+ }
+ else if(flags&ISOTP_RECEIVE)
+ {
+ rx = subscription.signal_->get_message()->get_id();
+ tx = subscription.get_tx_id();
+ }
+ std::shared_ptr<utils::socketcan_isotp_t> socket = std::make_shared<utils::socketcan_isotp_t>();
+ ret = socket->open(subscription.signal_->get_message()->get_bus_device_name(),rx,tx);
+ subscription.socket_ = socket;
+ }
+ else if(!bus_name.empty())
+ {
+ std::shared_ptr<utils::socketcan_isotp_t> socket = std::make_shared<utils::socketcan_isotp_t>();
+ ret = socket->open(bus_name, subscription.get_rx_id(),subscription.get_tx_id());
+ subscription.socket_ = socket;
+ }
+ subscription.index_ = (int)subscription.socket_->socket();
+ }
+#endif
#ifdef USE_FEATURE_J1939
- case socket_type::J1939_ADDR_CLAIM:
+ else if(flags&J1939_ADDR_CLAIM_PROTOCOL)
{
pgn_t pgn = J1939_NO_PGN;
if(!bus_name.empty())
subscription.socket_ = socket;
}
subscription.index_ = (int)subscription.socket_->socket();
- break;
}
- case socket_type::J1939:
+ else if(flags&J1939_PROTOCOL)
{
pgn_t pgn = J1939_NO_PGN;
if(subscription.signal_ != nullptr)
subscription.socket_ = socket;
}
subscription.index_ = (int)subscription.socket_->socket();
- break;
}
#endif
- default:
+ else
{
AFB_ERROR("Socket format not supported");
return INVALID_SOCKET;
- break;
- }
}
}
else{
subscription.signal_= sig;
// Make sure that socket is opened.
- if(open_socket(subscription,"",socket_type::J1939) < 0)
+ if(open_socket(subscription,"",J1939_PROTOCOL) < 0)
{
return -1;
}
}
#endif
+int low_can_subscription_t::create_rx_filter_isotp(low_can_subscription_t &subscription, std::shared_ptr<signal_t> sig)
+{
+ subscription.signal_= sig;
+
+ // Make sure that socket is opened.
+ if(open_socket(subscription,"",ISOTP_PROTOCOL|ISOTP_RECEIVE) < 0)
+ {
+ return -1;
+ }
+ return 0;
+}
+
/// @brief Create a RX_SETUP receive job to be used by the BCM socket for a CAN signal
/// subscription
///
/// @return 0 if ok else -1
int low_can_subscription_t::create_rx_filter_can(low_can_subscription_t &subscription, std::shared_ptr<signal_t> sig)
{
- uint32_t flags;
+ uint32_t flags_bcm;
float val;
struct timeval freq, timeout = {0, 0};
struct canfd_frame cfd;
if (is_fd)
{
- flags = SETTIMER|RX_NO_AUTOTIMER|CAN_FD_FRAME;
+ flags_bcm = SETTIMER|RX_NO_AUTOTIMER|CAN_FD_FRAME;
cfd.len = CANFD_MAX_DLEN;
- cm = can_message_t(CANFD_MAX_DLEN,sig->get_message()->get_id(),length_msg,sig->get_message()->get_format(),false,CAN_FD_FRAME,data,0);
+ cm = can_message_t( CANFD_MAX_DLEN,
+ sig->get_message()->get_id(),
+ length_msg,
+ false,
+ sig->get_message()->get_flags(),
+ data,
+ 0);
}
else
{
- flags = SETTIMER|RX_NO_AUTOTIMER;
+ flags_bcm = SETTIMER|RX_NO_AUTOTIMER;
cfd.len = CAN_MAX_DLEN;
- cm = can_message_t(CAN_MAX_DLEN,sig->get_message()->get_id(),length_msg,sig->get_message()->get_format(),false,0,data,0);
+ cm = can_message_t( CAN_MAX_DLEN,
+ sig->get_message()->get_id(),
+ length_msg,
+ false,
+ sig->get_message()->get_flags(),
+ data,
+ 0);
}
frequency_clock_t f = subscription.event_filter_.frequency == 0 ? subscription.signal_->get_frequency() : frequency_clock_t(subscription.event_filter_.frequency);
freq = f.get_timeval_from_period();
- struct bcm_msg bcm_msg = subscription.make_bcm_head(RX_SETUP, subscription.signal_->get_message()->get_id(), flags, timeout, freq);
+ struct bcm_msg bcm_msg = subscription.make_bcm_head(RX_SETUP, subscription.signal_->get_message()->get_id(), flags_bcm, timeout, freq);
std::vector<canfd_frame> cfd_vect = cm.convert_to_canfd_frame_vector();
int low_can_subscription_t::create_rx_filter(std::shared_ptr<signal_t> sig)
{
- #ifdef USE_FEATURE_J1939
- if(sig->get_message()->is_j1939())
+ if(!sig->get_message()->is_isotp() && !sig->get_message()->is_j1939())
+ {
+ return low_can_subscription_t::create_rx_filter_can(*this, sig);
+ }
+#ifdef USE_FEATURE_ISOTP
+ else if(sig->get_message()->is_isotp())
+ {
+ return low_can_subscription_t::create_rx_filter_isotp(*this,sig);
+ }
+#endif
+#ifdef USE_FEATURE_J1939
+ else if(sig->get_message()->is_j1939())
{
return low_can_subscription_t::create_rx_filter_j1939(*this, sig);
}
+#endif
else
{
- #endif
- return low_can_subscription_t::create_rx_filter_can(*this, sig);
- #ifdef USE_FEATURE_J1939
+ AFB_ERROR("Signal can't be j1939 and isotp");
+ return -1;
}
- #endif
}
int low_can_subscription_t::create_rx_filter_bcm(low_can_subscription_t &subscription, struct bcm_msg& bcm_msg)
{
// Make sure that socket is opened.
- if(subscription.open_socket(subscription,"",socket_type::BCM) < 0)
+ if(subscription.open_socket(subscription,"",BCM_PROTOCOL) < 0)
{return -1;}
// If it's not an OBD2 CAN ID then just add a simple RX_SETUP job
{
can_message_t *cm = static_cast<can_message_t*>(message);
- struct bcm_msg bcm_msg = subscription.make_bcm_head(TX_SEND, cm->get_id(),cm->get_flags() | TX_CP_CAN_ID); // TX_CP_CAN_ID -> copy in cfd the id of bcm
+ struct bcm_msg bcm_msg = subscription.make_bcm_head(TX_SEND, cm->get_id(),cm->get_flags()|TX_CP_CAN_ID); // TX_CP_CAN_ID -> copy in cfd the id of bcm
+ cm->set_bcm_msg(bcm_msg);
+
std::vector<canfd_frame> cfd_vect = cm->convert_to_canfd_frame_vector();
- for(auto cfd: cfd_vect)
+
+ if(subscription.open_socket(subscription, bus_name, BCM_PROTOCOL) < 0)
{
- subscription.add_one_bcm_frame(cfd, bcm_msg);
+ return -1;
}
- if(subscription.open_socket(subscription, bus_name,socket_type::BCM) < 0)
+ struct bcm_msg &bcm_cm = cm->get_bcm_msg();
+
+
+
+ if(cfd_vect.size() > 1)
{
+ AFB_ERROR("Multi frame BCM not implemented");
+ return -1;
+ }
+ else if(cfd_vect.size() == 1) // raw or fd
+ {
+ subscription.add_one_bcm_frame(cfd_vect[0], bcm_cm);
+
+ if(subscription.socket_->write_message(*cm) < 0)
+ {
+ AFB_ERROR("Error write message id : %d",cfd_vect[0].can_id);
return -1;
+ }
+ }
+ else // error
+ {
+ AFB_ERROR("Error no data available");
+ return -1;
}
- cm->set_bcm_msg(bcm_msg);
- subscription.socket_->write_message(*cm);
if(! subscription.socket_.get())
{
return -1;
//struct bcm_msg bcm_msg = subscription.make_bcm_head(TX_SEND, cfd.can_id);
//subscription.add_one_bcm_frame(cfd, bcm_msg);
- if(subscription.open_socket(subscription, bus_name, socket_type::J1939) < 0)
+ if(subscription.open_socket(subscription, bus_name, J1939_PROTOCOL) < 0)
{
return -1;
}
return 0;
}
-#endif
\ No newline at end of file
+#endif
+
+
+int low_can_subscription_t::isotp_send(low_can_subscription_t &subscription, message_t *message, const std::string& bus_name)
+{
+ //struct bcm_msg bcm_msg = subscription.make_bcm_head(TX_SEND, cfd.can_id);
+ //subscription.add_one_bcm_frame(cfd, bcm_msg);
+
+ if(subscription.open_socket(subscription, bus_name, ISOTP_PROTOCOL|ISOTP_SEND) < 0)
+ {
+ return -1;
+ }
+
+ can_message_t *cm = static_cast<can_message_t*>(message);
+ if(subscription.socket_->write_message(*cm) < 0)
+ {
+ AFB_ERROR("Error write iso tp message");
+ return -1;
+ }
+
+ return 0;
+}
\ No newline at end of file