types.hpp

Go to the documentation of this file.

 
 
#ifndef WATERLINKEDSONAR_TYPES_HPP
#define WATERLINKEDSONAR_TYPES_HPP
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <stdexcept>
#include <string>
 
namespace waterlinked::sonar {
 
inline constexpr const char* DEFAULT_IP = "192.168.194.96";
inline constexpr const char* MULTICAST_GROUP = "224.0.0.96";
inline constexpr std::uint16_t MULTICAST_PORT = 4747;
inline constexpr std::size_t MAX_DATAGRAM_SIZE = 65507;
 
struct About {
  std::string chipid;
  int hardware_revision;
  bool is_ready;
  int product_id;
  std::string product_name;
  std::string variant;
  std::string version;        
  std::string version_short;  
};
 
struct StatusEntry {
  std::string id;
  std::string message;
  std::string status;  
  bool operational;
};
 
struct Status {
  StatusEntry api;
  StatusEntry temperature;
  StatusEntry systems_check;
  std::optional<StatusEntry> time;
};
 
enum class AcousticsMode : std::uint8_t { LOW_FREQUENCY, HIGH_FREQUENCY };
 
enum class Salinity : std::uint8_t { SALT, FRESH };
 
struct Range {
  double min;
  double max;
};
 
struct UdpConfig {
  enum class Mode : std::uint8_t { MULTICAST, UNICAST, DISABLED };
  Mode mode{Mode::MULTICAST};
  std::string unicast_destination_ip;
  std::uint16_t unicast_destination_port{0};
};
 
struct TimeStatus {
  std::chrono::system_clock::time_point system_time;
  bool ntp_synced;
  std::string ntp_synced_to;
  std::optional<std::int64_t> ntp_seconds_since_last_sync;
};
 
struct ForceSyncResult {
  bool success;
  std::string message;
  TimeStatus status;  
};
 
class HttpError : public std::runtime_error {
 public:
  HttpError(const std::string& what, long status_code)
      : std::runtime_error(what), status_code_(status_code) {}
 
  [[nodiscard]] long status_code() const { return status_code_; }
 
 private:
  long status_code_;
};
 
class VersionError : public std::runtime_error {
 public:
  VersionError(const std::string& what, const std::string& min_version,
               const std::string& device_version)
      : std::runtime_error(what + " requires Sonar 3D-15 release " +
                           min_version + " or newer; device is " +
                           device_version) {}
};
 
class ProtocolError : public std::runtime_error {
  using std::runtime_error::runtime_error;
};
 
class TimeAlreadySynchronizedError : public HttpError {
 public:
  TimeAlreadySynchronizedError()
      : HttpError("system time is already synchronized", 409) {}
};
 
class ForceSyncOngoingError : public HttpError {
 public:
  ForceSyncOngoingError() : HttpError("a force-sync is already ongoing", 409) {}
};
 
const char* to_string(AcousticsMode mode);
 
const char* to_string(Salinity salinity);
 
const char* to_string(UdpConfig::Mode mode);
 
}  // namespace waterlinked::sonar
 
#endif  // WATERLINKEDSONAR_TYPES_HPP