X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fcan%2Fcan-bus.cpp;h=ff899e614cd35c2b0fd4ee5620a7d16a6969664e;hb=20708cd497b2f77f8b97fd215b6b5c1e2886869d;hp=034e0ac95d15acafe93ea25c48876c1bf693cb41;hpb=fe846f6698710163af5f2658cc90151259b09d0d;p=apps%2Fagl-service-can-low-level.git diff --git a/src/can/can-bus.cpp b/src/can/can-bus.cpp index 034e0ac9..ff899e61 100644 --- a/src/can/can-bus.cpp +++ b/src/can/can-bus.cpp @@ -15,8 +15,6 @@ * limitations under the License. */ -#include "can/can-bus.hpp" - #include #include #include @@ -29,9 +27,12 @@ #include #include -#include "can/can-decoder.hpp" -#include "utils/openxc-utils.hpp" -#include "obd2/diagnostic-manager.hpp" +#include "can-bus.hpp" + +#include "can-decoder.hpp" +#include "../configuration.hpp" +#include "../utils/signals.hpp" +#include "../utils/openxc-utils.hpp" extern "C" { @@ -54,11 +55,12 @@ can_bus_t::can_bus_t(int conf_file) { } + /** -* @brief thread to decoding raw CAN messages. +* @brief thread to decoding raw CAN messages. * -* @desc It will take from the can_message_q_ queue the next can message to process then it will search -* about signal subscribed if there is a valid afb_event for it. We only decode signal for which a +* @desc It will take from the can_message_q_ queue the next can message to process then it will search +* about signal subscribed if there is a valid afb_event for it. We only decode signal for which a * subscription has been made. Can message will be decoded using translateSignal that will pass it to the * corresponding decoding function if there is one assigned for that signal. If not, it will be the default * noopDecoder function that will operate on it. @@ -66,19 +68,17 @@ can_bus_t::can_bus_t(int conf_file) void can_bus_t::can_decode_message() { can_message_t can_message; - std::vector signals; + std::vector signals; openxc_VehicleMessage vehicle_message; openxc_DynamicField search_key, decoded_message; - decoder_t decoder; - while(is_decoding_) { std::unique_lock can_message_lock(can_message_mutex_); new_can_message_cv_.wait(can_message_lock); can_message = next_can_message(); - - /* First we have to found which CanSignal it is */ + + /* First we have to found which can_signal_t it is */ search_key = build_DynamicField((double)can_message.get_id()); signals.clear(); find_can_signals(search_key, signals); @@ -88,17 +88,17 @@ void can_bus_t::can_decode_message() { std::lock_guard subscribed_signals_lock(get_subscribed_signals_mutex()); std::map& s = get_subscribed_signals(); - + /* DEBUG message to make easier debugger STL containers... DEBUG(binder_interface, "Operator[] key char: %s, event valid? %d", sig.generic_name, afb_event_is_valid(s[sig.generic_name])); DEBUG(binder_interface, "Operator[] key string: %s, event valid? %d", sig.generic_name, afb_event_is_valid(s[std::string(sig.generic_name)])); DEBUG(binder_interface, "Nb elt matched char: %d", (int)s.count(sig.generic_name)); - DEBUG(binder_interface, "Nb elt matched string: %d", (int)s.count(std::string(sig.generic_name))); */ - if( s.find(sig->generic_name) != s.end() && afb_event_is_valid(s[sig->generic_name])) + DEBUG(binder_interface, "Nb elt matched string: %d", (int)s.count(std::string(sig.generic_name)));*/ + if( s.find(sig->get_generic_name()) != s.end() && afb_event_is_valid(s[sig->get_generic_name()])) { - decoded_message = decoder.translateSignal(*sig, can_message, get_can_signals()); + decoded_message = decoder_t::translateSignal(*sig, can_message, config->get_can_signals()); - openxc_SimpleMessage s_message = build_SimpleMessage(sig->generic_name, decoded_message); + openxc_SimpleMessage s_message = build_SimpleMessage(sig->get_generic_name(), decoded_message); vehicle_message = build_VehicleMessage_with_SimpleMessage(openxc_DynamicField_Type::openxc_DynamicField_Type_NUM, s_message); std::lock_guard decoded_can_message_lock(decoded_can_message_mutex_); @@ -110,7 +110,7 @@ void can_bus_t::can_decode_message() } /** -* @brief thread to push events to suscribers. It will read subscribed_signals map to look +* @brief thread to push events to suscribers. It will read subscribed_signals map to look * which are events that has to be pushed. */ void can_bus_t::can_event_push() @@ -118,7 +118,7 @@ void can_bus_t::can_event_push() openxc_VehicleMessage v_message; openxc_SimpleMessage s_message; json_object* jo; - + while(is_pushing_) { std::unique_lock decoded_can_message_lock(decoded_can_message_mutex_); @@ -149,7 +149,7 @@ void can_bus_t::start_threads() 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()) @@ -158,7 +158,7 @@ void can_bus_t::start_threads() /** * @brief Will stop all threads holded by can_bus_t object -* which are decoding and pushing then will wait that's +* which are decoding and pushing then will wait that's * they'll finish their job. */ void can_bus_t::stop_threads() @@ -168,7 +168,7 @@ void can_bus_t::stop_threads() } /** -* @brief Will initialize can_bus_dev_t objects after reading +* @brief Will initialize can_bus_dev_t objects after reading * the configuration file passed in the constructor. */ int can_bus_t::init_can_dev() @@ -235,7 +235,7 @@ std::vector can_bus_t::read_conf() {/** * @brief Telling if the pushing thread is running * This is the boolean value on which the while loop -* take its condition. Set it to false will stop the +* take its condition. Set it to false will stop the * according thread. * * @return true if pushing thread is running, false if not. @@ -284,9 +284,9 @@ std::mutex& can_bus_t::get_can_message_mutex() } /** -* @brief Return first can_message_t on the queue +* @brief Return first can_message_t on the queue * -* @return a can_message_t +* @return a can_message_t */ can_message_t can_bus_t::next_can_message() { @@ -300,7 +300,7 @@ can_message_t can_bus_t::next_can_message() can_msg.get_data()[0], can_msg.get_data()[1], can_msg.get_data()[2], can_msg.get_data()[3], can_msg.get_data()[4], can_msg.get_data()[5], can_msg.get_data()[6], can_msg.get_data()[7]); return can_msg; } - + return can_msg; } @@ -315,7 +315,7 @@ void can_bus_t::push_new_can_message(const can_message_t& can_msg) } /** -* @brief Return first openxc_VehicleMessage on the queue +* @brief Return first openxc_VehicleMessage on the queue * * @return a openxc_VehicleMessage containing a decoded can message */ @@ -330,7 +330,7 @@ openxc_VehicleMessage can_bus_t::next_vehicle_message() DEBUG(binder_interface, "next_vehicle_message: next vehicle message poped"); return v_msg; } - + return v_msg; } @@ -354,203 +354,3 @@ std::map> can_bus_t::get_can_devices return can_devices_m_; } -/******************************************************************************** -* -* can_bus_dev_t method implementation -* -*********************************************************************************/ -/** -* @brief Class constructor -* -* @param const string representing the device name into the linux /dev tree -*/ -can_bus_dev_t::can_bus_dev_t(const std::string& dev_name) - : device_name_{dev_name}, can_socket_{-1}, diagnostic_manager_{diagnostic_manager_t(*this)} -{} - -/** -* @brief Open the can socket and returning it -* -* @return -*/ -int can_bus_dev_t::open() -{ - const int canfd_on = 1; - const int timestamp_on = 1; - struct ifreq ifr; - struct timeval timeout; - - DEBUG(binder_interface, "CAN Handler socket : %d", can_socket_); - if (can_socket_ >= 0) - return 0; - - can_socket_ = ::socket(PF_CAN, SOCK_RAW, CAN_RAW); - DEBUG(binder_interface, "CAN Handler socket correctly initialized : %d", can_socket_); - if (can_socket_ < 0) - ERROR(binder_interface, "socket could not be created. Error was : %s", ::strerror(errno)); - else - { - /* Set timeout for read */ - ::setsockopt(can_socket_, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)); - /* Set timestamp for receveid frame */ - if (::setsockopt(can_socket_, SOL_SOCKET, SO_TIMESTAMP, ×tamp_on, sizeof(timestamp_on)) < 0) - WARNING(binder_interface, "setsockopt SO_TIMESTAMP error: %s", ::strerror(errno)); - DEBUG(binder_interface, "Switch CAN Handler socket to use fd mode"); - /* try to switch the socket into CAN_FD mode */ - if (::setsockopt(can_socket_, SOL_CAN_RAW, CAN_RAW_FD_FRAMES, &canfd_on, sizeof(canfd_on)) < 0) - { - NOTICE(binder_interface, "Can not switch into CAN Extended frame format."); - is_fdmode_on_ = false; - } else { - DEBUG(binder_interface, "Correctly set up CAN socket to use FD frames."); - is_fdmode_on_ = true; - } - - /* Attempts to open a socket to CAN bus */ - ::strcpy(ifr.ifr_name, device_name_.c_str()); - DEBUG(binder_interface, "ifr_name is : %s", ifr.ifr_name); - if(::ioctl(can_socket_, SIOCGIFINDEX, &ifr) < 0) - ERROR(binder_interface, "ioctl failed. Error was : %s", strerror(errno)); - else - { - txAddress_.can_family = AF_CAN; - txAddress_.can_ifindex = ifr.ifr_ifindex; - - /* And bind it to txAddress */ - DEBUG(binder_interface, "Bind the socket"); - if (::bind(can_socket_, (struct sockaddr *)&txAddress_, sizeof(txAddress_)) < 0) - ERROR(binder_interface, "Bind failed. %s", strerror(errno)); - else - return 0; - } - close(); - } - return -1; -} - -/** - * @brief Open the can socket and returning it - * - * @return - */ -int can_bus_dev_t::close() -{ - ::close(can_socket_); - can_socket_ = -1; - return can_socket_; -} - -/** -* @brief Read the can socket and retrieve canfd_frame -* -* @param const struct afb_binding_interface* interface pointer. Used to be able to log -* using application framework logger. -*/ -std::pair can_bus_dev_t::read() -{ - ssize_t nbytes; - //int maxdlen; - struct canfd_frame cfd; - - /* Test that socket is really opened */ - if (can_socket_ < 0) - { - ERROR(binder_interface, "read_can: Socket unavailable. Closing thread."); - is_running_ = false; - } - - nbytes = ::read(can_socket_, &cfd, CANFD_MTU); - - /* if we did not fit into CAN sized messages then stop_reading. */ - if (nbytes != CANFD_MTU && nbytes != CAN_MTU) - { - 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)); - } - - DEBUG(binder_interface, "read: Found id: %X, length: %X, data %02X%02X%02X%02X%02X%02X%02X%02X", cfd.can_id, cfd.len, - cfd.data[0], cfd.data[1], cfd.data[2], cfd.data[3], cfd.data[4], cfd.data[5], cfd.data[6], cfd.data[7]); - return std::pair(cfd, nbytes); -} - -/** -* @brief start reading threads and set flag is_running_ -* -* @param can_bus_t reference can_bus_t. it will be passed to the thread -* to allow using can_bus_t queue. -*/ -void can_bus_dev_t::start_reading(can_bus_t& can_bus) -{ - DEBUG(binder_interface, "Launching reading thread"); - 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; -} - -/** -* @brief stop the reading thread setting flag is_running_ to false and -* and wait that the thread finish its job. -*/ -void can_bus_dev_t::stop_reading() -{ - is_running_ = false; -} - -/** -* -* @brief Thread function used to read the can socket. -* -* @param[in] can_bus_dev_t object to be used to read the can socket -* @param[in] can_bus_t object used to fill can_message_q_ queue -*/ -void can_bus_dev_t::can_reader(can_bus_t& can_bus) -{ - can_message_t can_message; - - while(is_running_) - { - can_message.convert_from_canfd_frame(read()); - - { - std::lock_guard can_message_lock(can_bus.get_can_message_mutex()); - can_bus.push_new_can_message(can_message); - } - can_bus.get_new_can_message_cv().notify_one(); - } -} - -/** -* @brief Send a can message from a can_message_t object. -* -* @param const can_message_t& can_msg: the can message object to send -* @param const struct afb_binding_interface* interface pointer. Used to be able to log -* using application framework logger. -*/ -int can_bus_dev_t::send_can_message(can_message_t& can_msg) -{ - ssize_t nbytes; - canfd_frame f; - - f = can_msg.convert_to_canfd_frame(); - - if(can_socket_ >= 0) - { - nbytes = ::sendto(can_socket_, &f, sizeof(struct canfd_frame), 0, - (struct sockaddr*)&txAddress_, sizeof(txAddress_)); - if (nbytes == -1) - { - ERROR(binder_interface, "send_can_message: Sending CAN frame failed."); - return -1; - } - return (int)nbytes; - } - else - { - ERROR(binder_interface, "send_can_message: socket not initialized. Attempt to reopen can device socket."); - open(); - } - return 0; -} \ No newline at end of file