can_bus.hpp

Go to the documentation of this file.

#pragma once

#include <memory>
#include <string>

#include "real_time_tools/timer.hpp"
#include "real_time_tools/thread.hpp"
#include "real_time_tools/iostream.hpp"
#include "real_time_tools/spinner.hpp"

#include "real_time_tools/threadsafe/threadsafe_object.hpp"
#include "real_time_tools/threadsafe/threadsafe_timeseries.hpp"
#include "blmc_drivers/utils/os_interface.hpp"
#include "blmc_drivers/devices/device_interface.hpp"


namespace blmc_drivers
{

class CanBusFrame
{
public:
    std::array<uint8_t, 8> data;
    uint8_t dlc;
    can_id_t id;

    void print() const
    {
        rt_printf("---------------------------\n");
        rt_printf("can bus frame data");
        for(auto& datum : data)
        {
            rt_printf(" :%d", datum);
        }
        rt_printf("\n");

        rt_printf("id: %d\n", id);

        rt_printf("dlc: %d\n", dlc);

        rt_printf("---------------------------\n");
    }
};

class CanBusConnection
{
public:
    struct sockaddr_can send_addr;
    int socket;
};

class CanBusInterface: public DeviceInterface
{
public:
    virtual ~CanBusInterface() {}


    typedef real_time_tools::ThreadsafeTimeseries<CanBusFrame> CanframeTimeseries;

    virtual std::shared_ptr<const CanframeTimeseries> get_output_frame()
      const = 0;

    virtual std::shared_ptr<const CanframeTimeseries> get_input_frame() = 0;

    virtual std::shared_ptr<const CanframeTimeseries> get_sent_input_frame() = 0;

    virtual void set_input_frame(const CanBusFrame& input_frame) = 0;

    virtual void send_if_input_changed() = 0;
};

class CanBus: public CanBusInterface
{
public:
    CanBus(const std::string& can_interface_name,
               const size_t& history_length = 1000);

    virtual ~CanBus();
    
    std::shared_ptr<const CanframeTimeseries> get_output_frame() const
    {
        return output_;
    }

    virtual std::shared_ptr<const CanframeTimeseries>  get_input_frame()
    {
        return input_;
    }

    virtual std::shared_ptr<const CanframeTimeseries> get_sent_input_frame()
    {
        return sent_input_;
    }

    virtual void set_input_frame(const CanBusFrame& input_frame)
    {
        input_->append(input_frame);
    }

    virtual void send_if_input_changed();

private:

    static THREAD_FUNCTION_RETURN_TYPE loop(void* instance_pointer)
    {
        ((CanBus*)(instance_pointer))->loop();
        return THREAD_FUNCTION_RETURN_VALUE;
    }

    void loop();

    void send_frame(const CanBusFrame& unstamped_can_frame);

    CanBusFrame receive_frame();

    CanBusConnection setup_can(std::string name, uint32_t err_mask);

    real_time_tools::SingletypeThreadsafeObject<CanBusConnection, 1> can_connection_;

    std::shared_ptr<real_time_tools::ThreadsafeTimeseries<CanBusFrame> > input_;

    std::shared_ptr<real_time_tools::ThreadsafeTimeseries<CanBusFrame> > sent_input_;

    std::shared_ptr<real_time_tools::ThreadsafeTimeseries<CanBusFrame> > output_;

    bool is_loop_active_;

    real_time_tools::RealTimeThread rt_thread_;

    std::string log_dir_;

    std::string name_;
};

}