spi_bus.hpp

Go to the documentation of this file.

#pragma once

#include "master_board_sdk/master_board_interface.h"
#include "blmc_drivers/devices/motor.hpp"
#include "real_time_tools/thread.hpp"
#include "real_time_tools/threadsafe/threadsafe_timeseries.hpp"

#include "blmc_drivers/devices/motor_board.hpp"

namespace blmc_drivers
{

class SpiBus: public DeviceInterface
{

public:
    SpiBus(
      std::shared_ptr<MasterBoardInterface> main_board_interface,
      const size_t& nb_udrivers, const size_t& history_length=1000);

    ~SpiBus();

    virtual std::shared_ptr<const MotorInterface::ScalarTimeseries>
    get_measurement(
      const size_t udriver_id,
      const MotorBoardInterface::MeasurementIndex& index) const ;

    virtual std::shared_ptr<const MotorBoardInterface::StatusTimeseries>
    get_status(const size_t udriver_id) const;

    virtual std::shared_ptr<const MotorInterface::ScalarTimeseries> get_control(
      const size_t udriver_id,
      const MotorBoardInterface::ControlIndex& index) const;

    virtual std::shared_ptr<const MotorBoardInterface::CommandTimeseries>
    get_command(const size_t udriver_id) const;

    virtual std::shared_ptr<const MotorInterface::ScalarTimeseries>
    get_sent_control(
        const size_t udriver_id,
        const MotorBoardInterface::ControlIndex& index) const;

    virtual std::shared_ptr<const MotorBoardInterface::CommandTimeseries>
    get_sent_command(const size_t udriver_id) const;

    virtual void set_control(const size_t udriver_id, const double& control,
                             const MotorBoardInterface::ControlIndex& index);
    
    virtual void set_command(const size_t udriver_id, 
                             const MotorBoardCommand& command);

    virtual void send_if_input_changed();

    bool is_ready();

    void wait_until_ready();

private:
    static THREAD_FUNCTION_RETURN_TYPE loop(void* instance_pointer)
    {
        static_cast<SpiBus*>(instance_pointer)->loop();
        return THREAD_FUNCTION_RETURN_VALUE;
    }

    void loop();

    void send_newest_command();

    void send_newest_controls();

    std::shared_ptr<MasterBoardInterface> main_board_interface_;

    size_t nb_udrivers_;

    std::vector<std::shared_ptr<MotorInterface::ScalarTimeseries> > measurement_;

    std::vector<std::shared_ptr<MotorBoardInterface::StatusTimeseries> > status_;

    std::vector<std::shared_ptr<MotorInterface::ScalarTimeseries> > control_;

    std::vector<std::shared_ptr<MotorBoardInterface::CommandTimeseries> >command_;

    size_t history_length_;

    std::vector<std::shared_ptr<MotorInterface::ScalarTimeseries> > sent_control_;

    std::vector<std::shared_ptr<MotorBoardInterface::CommandTimeseries> > sent_command_;

    bool is_loop_active_;

    bool motors_are_paused_;

    int control_timeout_ms_;

    real_time_tools::RealTimeThread rt_thread_;

    std::array<bool, 12> motor_index_toggle_bits_;
};

}