group.hpp

Go to the documentation of this file.

#pragma once

#include "hebi.h"

#include <array>
#include <functional>
#include <memory>
#include <mutex>
#include <vector>

#include "util.hpp"

namespace hebi {

class LogFile;
class Group;
class GroupCommand;
class GroupFeedback;
class GroupInfo;

namespace util {

class MobileIO;

} // namespace util

using GroupFeedbackHandler = std::function<void(const GroupFeedback&)>;

enum InfoExtraFields : uint64_t {
  EthernetInfo = HebiInfoExtraFieldsEthernetInfo, // IP address, subnet, etc.
  UserData = HebiInfoExtraFieldsUserData, // user data bytes and floats
  FirmwareInfo = HebiInfoExtraFieldsFirmwareInfo, // mechanical/electrical revs, etc
  RuntimeData = HebiInfoExtraFieldsRuntimeData, // time on, time commanded
};

class UserState {
  friend class Group;

private:
  std::array<bool, 9> has_state_bits_;
  std::array<double, 9> state_values_;
public:
  // Creates a user state with all values empty
  UserState() = default;
  // Creates a user state with all values specified
  UserState(double v1, double v2, double v3, double v4, double v5, double v6, double v7,
            double v8, double v9) :
            state_values_({v1, v2, v3, v4, v5, v6, v7, v8, v9}) {
    // Has state for all fields
    has_state_bits_.fill(true);
  }

  bool hasValue(size_t number) const {
    return (number >= 1 && number <= 9) ? (has_state_bits_[number - 1]) : false;
  }

  double getValue(size_t number) const {
    return (number >= 1 && number <= 9) ? (state_values_[number - 1]) : 0;
  }

  void setValue(size_t number, double value) {
    if (number < 1 || number > 9)
      return;
    has_state_bits_[number - 1] = true;
    state_values_[number - 1] = value;
  }

  void clearValue(size_t number) {
    if (number < 1 || number > 9)
      return;
    has_state_bits_[number - 1] = false;
  }
};

class Group final {
  friend class util::MobileIO;

private:
  HebiGroupPtr internal_;

  const size_t number_of_modules_;

  std::mutex handler_lock_;

  std::vector<GroupFeedbackHandler> handlers_;

#ifndef DOXYGEN_OMIT_INTERNAL

  friend void callbackWrapper(HebiGroupFeedbackPtr group_feedback, void* user_data);
#endif // DOXYGEN_OMIT_INTERNAL

  void callAttachedHandlers(HebiGroupFeedbackPtr group_feedback);

public:
  static const int32_t DEFAULT_TIMEOUT_MS = 500;

#ifndef DOXYGEN_OMIT_INTERNAL

  Group(HebiGroupPtr group, float initial_feedback_frequency = 0.0f, int32_t initial_command_lifetime = 0);
#endif // DOXYGEN_OMIT_INTERNAL

  ~Group() noexcept; /* annotating specified destructor as noexcept is best-practice */

  size_t size() const;

  bool setCommandLifetimeMs(int32_t ms);

  int32_t getCommandLifetimeMs() const;

  bool sendCommand(const GroupCommand& group_command);

  bool sendCommandWithAcknowledgement(const GroupCommand& group_command, int32_t timeout_ms = DEFAULT_TIMEOUT_MS);

  bool sendFeedbackRequest();

  bool getNextFeedback(GroupFeedback& feedback, int32_t timeout_ms = DEFAULT_TIMEOUT_MS);

  bool requestInfo(GroupInfo& info, int32_t timeout_ms = DEFAULT_TIMEOUT_MS);

  bool requestInfoExtra(GroupInfo& info, InfoExtraFields extra_fields, int32_t timeout_ms = DEFAULT_TIMEOUT_MS);

  std::string startLog(const std::string& dir) const;

  std::string startLog(const std::string& dir, const std::string& file) const;

  std::shared_ptr<LogFile> stopLog() const;

  bool logUserState(const UserState& state) const;

  bool setFeedbackFrequencyHz(float frequency);
  float getFeedbackFrequencyHz() const;
  void addFeedbackHandler(GroupFeedbackHandler handler);
  void clearFeedbackHandlers();

  static std::shared_ptr<Group> createImitation(size_t size);

private:
  HEBI_DISABLE_COPY_MOVE(Group)
};

} // namespace hebi