manager.h

Go to the documentation of this file.

#ifndef FASTCAT_MANAGER_H_
#define FASTCAT_MANAGER_H_
 
// Include related header (for cc files)
 
// Include c then c++ libraries
#include <memory>
#include <mutex>
#include <queue>
#include <unordered_map>
#include <vector>
 
// Include external then project includes
#include <yaml-cpp/yaml.h>
 
#include "fastcat/thread_safe_queue.h"
#include "fastcat/device_base.h"
#include "fastcat/jsd/actuator.h"
#include "fastcat/jsd/jsd_device_base.h"
#include "jsd/jsd.h"
 
namespace fastcat
{
typedef std::pair<std::string, std::shared_ptr<DeviceBase>> DevicePair;
typedef std::pair<std::string, jsd_t*>                      JSDPair;
 
class Manager
{
 public:
  Manager();
  ~Manager();
 
  void Shutdown();
 
  bool ConfigFromYaml(const YAML::Node& node, double external_time = -1);
 
  bool CreateConfigFromYaml(const YAML::Node& node, double external_time = -1);
 
  bool InitHardware();
 
  bool Process(double external_time = -1);
 
  void QueueCommand(DeviceCmd& cmd);
 
  std::vector<DeviceState> GetDeviceStates();
 
  std::vector<std::shared_ptr<const DeviceState>> GetDeviceStatePointers();
 
  double GetTargetLoopRate();
 
  bool IsFaulted();
 
  bool RecoverBus(std::string ifname);
 
  bool ExecuteDeviceReset(std::string device_name);
 
  bool ExecuteDeviceFault(std::string device_name);
 
  void ExecuteAllDeviceResets();
 
  void ExecuteAllDeviceFaults();
 
  bool IsSdoResponseQueueEmpty();
 
  bool PopSdoResponseQueue(SdoResponse& res);
 
  bool GetActuatorParams(const std::string&                 name,
                         fastcat::Actuator::ActuatorParams& param);
 
  void GetDeviceNamesByType(std::vector<std::string>&,
                            fastcat::DeviceStateType);
 
  void SetExplicitInterpolationAlgorithmCubic();
 
  void SetExplicitInterpolationAlgorithmLinear();
 
  void SetExplicitInterpolationTimestampSourceCspMessage();
 
  void SetExplicitInterpolationTimestampSourceClock();
 
  bool SetExplicitInterpolationCyclesDelay(size_t delay);
 
  bool SetInterpolationCyclesStale(size_t cycles);
 
 
 private:
  bool ConfigJSDBusFromYaml(const YAML::Node& node, double external_time);
  bool ConfigFastcatBusFromYaml(const YAML::Node& node, double external_time);
  bool ConfigOfflineBusFromYaml(const YAML::Node& node, double external_time);
  bool WriteCommands();
  bool ConfigSignals();
  bool SortFastcatDevice(
      std::shared_ptr<DeviceBase>               device,
      std::vector<std::shared_ptr<DeviceBase>>& sorted_devices,
      std::vector<std::string>                  parents);
 
  bool LoadActuatorPosFile();
  bool ValidateActuatorPosFile();
  bool SetActuatorPositions();
  void GetActuatorPositions();
  void SaveActuatorPosFile();
  bool CheckDeviceNameIsUnique(std::string name);
  struct JsdBusInitParams {
    std::string ifname;
    jsd_t*      jsd;
    bool        enable_autorecovery;
  };
 
  double                        target_loop_rate_hz_                = 0.0;
  bool                          zero_latency_required_              = true;
  bool                          faulted_                            = true;
  bool                          actuator_fault_on_missing_pos_file_ = true;
  bool                          online_devices_exist_               = false;
  std::string                   actuator_position_directory_;
  std::map<std::string, jsd_t*> jsd_map_;
 
  std::map<std::string, std::shared_ptr<DeviceBase>> device_map_;
  std::vector<std::shared_ptr<DeviceBase>>           fastcat_device_list_;
  std::vector<std::shared_ptr<JsdDeviceBase>>        jsd_device_list_;
  std::shared_ptr<ThreadSafeQueue<DeviceCmd>>             cmd_queue_;
  std::vector<DeviceState>                           states_;
  std::map<std::string, ActuatorPosData>             actuator_pos_map_;
  std::unordered_map<std::string, bool>              unique_device_map_;
  std::shared_ptr<std::queue<SdoResponse>>           sdo_response_queue_;
 
  std::vector<JsdBusInitParams> pending_jsd_inits_;
 
  std::mutex parameter_mutex_;
 
};
}  // namespace fastcat
 
#endif