can_hardware_interface.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef CAN_HARDWARE_INTERFACE_HPP
#define CAN_HARDWARE_INTERFACE_HPP
 
#include "isobus/hardware_integration/can_hardware_plugin.hpp"
#include "isobus/isobus/can_hardware_abstraction.hpp"
#include "isobus/isobus/can_message_frame.hpp"
#include "isobus/utility/event_dispatcher.hpp"
 
#include <atomic>
#include <cstdint>
#include <cstring>
#include <deque>
#include <vector>
 
#if !defined CAN_STACK_DISABLE_THREADS && !defined ARDUINO
#include <condition_variable>
#include <thread>
#endif
 
namespace isobus
{
    class CANHardwareInterface
    {
    public:
        static std::uint8_t get_number_of_can_channels();
 
        static bool set_number_of_can_channels(std::uint8_t value, std::size_t queueCapacity = 40);
 
        static bool assign_can_channel_frame_handler(std::uint8_t channelIndex, std::shared_ptr<CANHardwarePlugin> canDriver);
 
        static bool unassign_can_channel_frame_handler(std::uint8_t channelIndex);
 
        static std::shared_ptr<CANHardwarePlugin> get_assigned_can_channel_frame_handler(std::uint8_t channelIndex);
 
        static bool start();
 
        static bool stop();
 
        static bool is_running();
 
        static bool transmit_can_frame(const CANMessageFrame &frame);
 
        static EventDispatcher<const CANMessageFrame &> &get_can_frame_received_event_dispatcher();
 
        static EventDispatcher<const CANMessageFrame &> &get_can_frame_transmitted_event_dispatcher();
 
        static EventDispatcher<> &get_periodic_update_event_dispatcher();
 
        static void update();
 
        static void set_periodic_update_interval(std::uint32_t value);
 
        static std::uint32_t get_periodic_update_interval();
 
    private:
        class CANHardware
        {
        public:
            explicit CANHardware(std::size_t queueCapacity);
 
            virtual ~CANHardware();
 
            bool start();
 
            bool stop();
 
            bool transmit_can_frame(const CANMessageFrame &frame) const;
 
            bool receive_can_frame();
 
#if !defined CAN_STACK_DISABLE_THREADS && !defined ARDUINO
            void start_threads();
 
            void stop_threads();
 
            void receive_thread_function();
 
            std::unique_ptr<std::thread> receiveMessageThread; 
            bool receiveThreadRunning = false; 
#endif
 
            std::shared_ptr<CANHardwarePlugin> frameHandler; 
 
            LockFreeQueue<CANMessageFrame> messagesToBeTransmittedQueue; 
            LockFreeQueue<CANMessageFrame> receivedMessagesQueue; 
        };
 
        static CANHardwareInterface SINGLETON;
 
        static constexpr std::uint32_t PERIODIC_UPDATE_INTERVAL = 4;
 
#if !defined CAN_STACK_DISABLE_THREADS && !defined ARDUINO
        virtual ~CANHardwareInterface();
 
        static void update_thread_function();
 
        static void start_threads();
 
        static void stop_threads();
 
        static std::unique_ptr<std::thread> updateThread; 
        static std::condition_variable updateThreadWakeupCondition; 
#endif
        static std::uint32_t lastUpdateTimestamp; 
        static std::uint32_t periodicUpdateInterval; 
        static EventDispatcher<const CANMessageFrame &> frameReceivedEventDispatcher; 
        static EventDispatcher<const CANMessageFrame &> frameTransmittedEventDispatcher; 
        static EventDispatcher<> periodicUpdateEventDispatcher; 
 
        static std::vector<std::unique_ptr<CANHardware>> hardwareChannels; 
        static Mutex hardwareChannelsMutex; 
        static Mutex updateMutex; 
        static bool started; 
    };
}
#endif // CAN_HARDWARE_INTERFACE_HPP