*
*********************************************************************************/
-can_bus_t::can_bus_t(int& conf_file)
+can_bus_t::can_bus_t(int conf_file)
: conf_file_{conf_file}
{
}
decoder_t decoder;
DEBUG(binder_interface, "Beginning of decoding thread.");
- while(is_decoding())
+ while(is_decoding_)
{
{
std::unique_lock<std::mutex> can_message_lock(can_message_mutex_);
json_object* jo;
DEBUG(binder_interface, "Beginning of the pushing thread");
- while(is_pushing())
+ while(is_pushing_)
{
{
std::unique_lock<std::mutex> decoded_can_message_lock(decoded_can_message_mutex_);
void can_bus_t::start_threads()
{
- th_decoding_ = std::thread(&can_bus_t::can_decode_message, this);
is_decoding_ = true;
- th_pushing_ = std::thread(&can_bus_t::can_event_push, this);
+ th_decoding_ = std::thread(&can_bus_t::can_decode_message, this);
+ if(!th_decoding_.joinable())
+ is_decoding_ = false;
+
is_pushing_ = true;
+ th_pushing_ = std::thread(&can_bus_t::can_event_push, this);
+ if(!th_pushing_.joinable())
+ is_pushing_ = false;
}
void can_bus_t::stop_threads()
{
is_decoding_ = false;
is_pushing_ = false;
- th_decoding_.join();
- th_pushing_.join();
-}
-
-bool can_bus_t::is_decoding()
-{
- return is_decoding_;
-}
-
-bool can_bus_t::is_pushing()
-{
- return is_pushing_;
}
int can_bus_t::init_can_dev()
for(const auto& device : devices_name)
{
- can_bus_dev_t can_bus_device_handler(device);
- if (can_bus_device_handler.open() == 0)
+ can_devices_m_[device] = std::make_shared<can_bus_dev_t>(device);
+ if (can_devices_m_[device]->open() == 0)
{
i++;
DEBUG(binder_interface, "Start reading thread");
- can_bus_device_handler.start_reading(std::ref(*this));
+ can_devices_m_[device]->start_reading(*this);
}
else
ERROR(binder_interface, "Can't open device %s", device.c_str());
has_vehicle_message_ = true;
}
+std::map<std::string, std::shared_ptr<can_bus_dev_t>> can_bus_t::get_can_devices()
+{
+ return can_devices_m_;
+}
+
/********************************************************************************
*
* can_bus_dev_t method implementation
{
ssize_t nbytes;
//int maxdlen;
- canfd_frame canfd_frame;
+ struct canfd_frame cfd;
/* Test that socket is really opened */
if (can_socket_ < 0)
is_running_ = false;
}
- nbytes = ::read(can_socket_, &canfd_frame, CANFD_MTU);
+ nbytes = ::read(can_socket_, &cfd, CANFD_MTU);
- switch(nbytes)
+ /* if we did not fit into CAN sized messages then stop_reading. */
+ if (nbytes != CANFD_MTU && nbytes != CAN_MTU)
{
- case CANFD_MTU:
- DEBUG(binder_interface, "read_can: Got an CAN FD frame with length %d", canfd_frame.len);
- //maxdlen = CANFD_MAX_DLEN;
- break;
- case CAN_MTU:
- DEBUG(binder_interface, "read_can: Got a legacy CAN frame with length %d", canfd_frame.len);
- //maxdlen = CAN_MAX_DLEN;
- break;
- default:
- if (errno == ENETDOWN)
- ERROR(binder_interface, "read_can: %s binder_interface down", device_name_);
- ERROR(binder_interface, "read_can: Error reading CAN bus");
- ::memset(&canfd_frame, 0, sizeof(canfd_frame));
- is_running_ = false;
- break;
+ if (errno == ENETDOWN)
+ ERROR(binder_interface, "read: %s CAN device down", device_name_);
+ ERROR(binder_interface, "read: Incomplete CAN(FD) frame");
+ ::memset(&cfd, 0, sizeof(cfd));
}
-
- return canfd_frame;
-}
-bool can_bus_dev_t::is_running()
-{
- return is_running_;
+ return cfd;
}
void can_bus_dev_t::start_reading(can_bus_t& can_bus)
{
DEBUG(binder_interface, "Launching reading thread");
- th_reading_ = std::thread(&can_bus_dev_t::can_reader, this, std::ref(can_bus));
is_running_ = true;
+ th_reading_ = std::thread(&can_bus_dev_t::can_reader, this, std::ref(can_bus));
+ if(!th_reading_.joinable())
+ is_running_ = false;
}
void can_bus_dev_t::stop_reading()
{
is_running_ = false;
- th_reading_.join();
}
void can_bus_dev_t::can_reader(can_bus_t& can_bus)
can_message_t can_message;
DEBUG(binder_interface, "Beginning of reading thread");
- while(is_running())
+ while(is_running_)
{
can_message.convert_from_canfd_frame(read());