receiver.hpp

Go to the documentation of this file.

 
 
#ifndef WATERLINKEDSONAR_RECEIVER_HPP
#define WATERLINKEDSONAR_RECEIVER_HPP
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <system_error>
#include <thread>
#include <vector>
#include <waterlinkedsonar/messages.hpp>
#include <waterlinkedsonar/rip.hpp>
#include <waterlinkedsonar/udp_socket.hpp>
 
namespace waterlinked::sonar {
 
struct ReceiverOptions {
  std::optional<std::string> source_ip;
};
 
struct ReceiverStats {
  std::uint64_t datagrams_received{0};
  std::uint64_t range_images{0};
  std::uint64_t bitmap_images{0};
  std::uint64_t imu_batches{0};
  std::uint64_t unknown_type{0};  
  std::uint64_t decode_errors{0};
  std::uint64_t filtered_source{0};  
  std::uint32_t last_sequence_id{
      0};  
  std::chrono::steady_clock::time_point last_datagram_time;
};
 
class Receiver {
 public:
  explicit Receiver(std::unique_ptr<UdpSocket> socket,
                    ReceiverOptions options = {});
 
  ~Receiver();
 
  Receiver(const Receiver&) = delete;
  Receiver& operator=(const Receiver&) = delete;
 
  void on_range_image(std::function<void(const RangeImageView&)> cb);
 
  void on_bitmap_image(std::function<void(const BitmapImageView&)> cb);
 
  void on_imu_batch(std::function<void(const ImuBatchView&)> cb);
 
  void on_decode_error(std::function<void(rip::DecodeStatus)> cb);
 
  void on_socket_error(std::function<void(const std::error_code&)> cb);
 
  void start();
 
  void stop();
 
  [[nodiscard]] bool running() const;
 
  [[nodiscard]] ReceiverStats stats() const;
 
 private:
  void receive_loop();
 
  std::unique_ptr<UdpSocket> socket_;
  ReceiverOptions options_;
  rip::Decoder decoder_;
 
  std::vector<std::function<void(const RangeImageView&)>> range_callbacks_;
  std::vector<std::function<void(const BitmapImageView&)>> bitmap_callbacks_;
  std::vector<std::function<void(const ImuBatchView&)>> imu_callbacks_;
  std::vector<std::function<void(rip::DecodeStatus)>> decode_error_callbacks_;
  std::vector<std::function<void(const std::error_code&)>>
      socket_error_callbacks_;
 
  std::thread thread_;
  std::atomic<bool> running_{false};
  bool started_{false};
 
  // Written only by the receive thread.
  std::atomic<std::uint64_t> datagrams_received_{0};
  std::atomic<std::uint64_t> range_images_{0};
  std::atomic<std::uint64_t> bitmap_images_{0};
  std::atomic<std::uint64_t> imu_batches_{0};
  std::atomic<std::uint64_t> unknown_type_{0};
  std::atomic<std::uint64_t> decode_errors_{0};
  std::atomic<std::uint64_t> filtered_source_{0};
  std::atomic<std::uint32_t> last_sequence_id_{0};
  std::atomic<std::chrono::steady_clock::time_point::rep> last_datagram_ns_{0};
};
 
}  // namespace waterlinked::sonar
 
#endif  // WATERLINKEDSONAR_RECEIVER_HPP