Finish the example of UDP reading

.github/workflows/ci.yml

@@ -1,5 +1,9 @@
 name: ci
 on:
+  pull_request:
+    branches:
+      - dev
+      - master
   push:
     branches:
       - dev

backend/CMakeLists.txt

@@ -38,3 +38,4 @@ add_subdirectory(srs)
 
 add_executable(srs_control main.cpp)
 target_link_libraries(srs_control PRIVATE srscpp spdlog::spdlog CLI11::CLI11 Boost::thread)
+target_compile_definitions(srs_control PUBLIC SRS_PROJECT_VERSION="v${CMAKE_PROJECT_VERSION}")

backend/main.cpp

@@ -2,6 +2,7 @@
 #include <CLI/CLI.hpp>
 #include <spdlog/spdlog.h>
 #include <srs/Application.hpp>
+#include <print>
 
 auto main(int argc, char** argv) -> int
 {
@@ -13,8 +14,10 @@ auto main(int argc, char** argv) -> int
         auto spdlog_level = spdlog::level::info;
         auto print_mode = srs::DataPrintMode::print_speed;
         auto output_filenames = std::vector<std::string>{ "output.bin" };
+        auto is_version_print = false;
 
-        cli_args.add_option("-v, --verbose-level", spdlog_level, "set log level")
+        cli_args.add_flag("-v, --version", is_version_print, "show the current version");
+        cli_args.add_option("-l, --log-level", spdlog_level, "set log level")
             ->transform(CLI::CheckedTransformer(spd_log_map, CLI::ignore_case))
             ->capture_default_str();
         cli_args.add_option("-p, --print-mode", print_mode, "set data print mode")
@@ -25,14 +28,19 @@ auto main(int argc, char** argv) -> int
             ->expected(0, -1);
         cli_args.parse(argc, argv);
 
+        if(is_version_print)
+        {
+            std::println("{}", SRS_PROJECT_VERSION);
+            return 0;
+        }
+
         spdlog::set_level(spdlog_level);
 
         auto app = srs::App{};
         app.set_remote_endpoint(srs::DEFAULT_SRS_IP, srs::DEFAULT_SRS_CONTROL_PORT);
         app.set_print_mode(print_mode);
         app.set_output_filenames(output_filenames);
 
-
         app.read_data();
         app.switch_on();
         app.run();

backend/srs/CMakeLists.txt

@@ -41,6 +41,7 @@ target_sources(
            publicHeaders
            FILES
            Application.hpp
+           format.hpp
            srs.hpp)
 
 target_link_libraries(srscpp PRIVATE $<BUILD_LOCAL_INTERFACE:srs_data>)

backend/srs/data/DataStructsFormat.hpp

@@ -1,6 +1,6 @@
-#include <srs/data/DataStructs.hpp>
 #include <fmt/format.h>
 #include <fmt/ranges.h>
+#include <srs/data/DataStructs.hpp>
 
 template <>
 class fmt::formatter<srs::ReceiveDataHeader>
@@ -10,13 +10,14 @@ class fmt::formatter<srs::ReceiveDataHeader>
     template <typename FmtContent>
     constexpr auto format(const srs::ReceiveDataHeader& header, FmtContent& ctn) const
     {
-        return format_to(ctn.out(),
-                         "frame counter: {}, vmm tag: {}, fec id: {:08b}, udp timestamp: {}, overflow: {}",
-                         header.frame_counter,
-                         fmt::join(header.vmm_tag, ""),
-                         header.fec_id,
-                         header.udp_timestamp,
-                         header.overflow);
+        return format_to(
+            ctn.out(),
+            "Header data: [frame counter: {}, vmm tag: {}, fec id: {:08b}, udp timestamp: {}, overflow: {}]",
+            header.frame_counter,
+            fmt::join(header.vmm_tag, ""),
+            header.fec_id,
+            header.udp_timestamp,
+            header.overflow);
     }
 };
 
@@ -28,7 +29,8 @@ class fmt::formatter<srs::MarkerData>
     template <typename FmtContent>
     constexpr auto format(const srs::MarkerData& marker, FmtContent& ctn) const
     {
-        return format_to(ctn.out(), "vmm id: {}, srs timestamp: {}", marker.vmm_id, marker.srs_timestamp);
+        return format_to(
+            ctn.out(), "Marker data: [vmm id: {}, srs timestamp: {}]", marker.vmm_id, marker.srs_timestamp);
     }
 };
 
@@ -39,15 +41,32 @@ class fmt::formatter<srs::HitData>
     static constexpr auto parse(format_parse_context& ctx) { return ctx.end(); }
     template <typename FmtContent>
     constexpr auto format(const srs::HitData& hit, FmtContent& ctn) const
+    {
+        return format_to(
+            ctn.out(),
+            "Hit data: [Over threshold: {}, channel num: {}, tdc: {}, adc: {}, offset: {}, vmm id: {}, bc id: {}]",
+            hit.is_over_threshold,
+            hit.channel_num,
+            hit.tdc,
+            hit.adc,
+            hit.offset,
+            hit.vmm_id,
+            hit.bc_id);
+    }
+};
+
+template <>
+class fmt::formatter<srs::StructData>
+{
+  public:
+    static constexpr auto parse(format_parse_context& ctx) { return ctx.end(); }
+    template <typename FmtContent>
+    constexpr auto format(const srs::StructData& struct_data, FmtContent& ctn) const
     {
         return format_to(ctn.out(),
-                         "Over threshold: {}, channel num: {}, tdc: {}, adc: {}, offset: {}, vmm id: {}, bc id: {}",
-                         hit.is_over_threshold,
-                         hit.channel_num,
-                         hit.tdc,
-                         hit.adc,
-                         hit.offset,
-                         hit.vmm_id,
-                         hit.bc_id);
+                         "{}\n{}\n{}\n",
+                         struct_data.header,
+                         fmt::join(struct_data.marker_data, "\n"),
+                         fmt::join(struct_data.hit_data, "\n"));
     }
 };

backend/srs/format.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+#include <srs/data/DataStructsFormat.hpp>

backend/srs/readers/ProtoMsgReader.cpp

@@ -10,6 +10,8 @@ namespace srs
     {
     }
 
+    ProtoMsgReader::~ProtoMsgReader() = default;
+
     auto ProtoMsgReader::convert(std::string_view msg, StructData& struct_data)
     {
         const auto& prot_struct = proto_deserializer_->convert(msg);

backend/srs/readers/ProtoMsgReader.hpp

@@ -13,6 +13,12 @@ namespace srs
       public:
         ProtoMsgReader();
 
+        ProtoMsgReader(const ProtoMsgReader&) = delete;
+        ProtoMsgReader(ProtoMsgReader&&) = default;
+        ProtoMsgReader& operator=(const ProtoMsgReader&) = delete;
+        ProtoMsgReader& operator=(ProtoMsgReader&&) = default;
+        ~ProtoMsgReader();
+
         auto convert(std::string_view msg, StructData& struct_data);
         auto convert(std::string_view msg) -> const StructData&;
 

examples/readUDP/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.22)
+project(readUDP)
+
+set(CMAKE_CXX_STANDARD 17)
+add_executable(main main.cpp)
+
+find_package(Boost REQUIRED)
+find_package(srs REQUIRED)
+find_package(fmt REQUIRED)
+
+target_link_libraries(main PRIVATE Boost::boost srs::srs fmt::fmt)

examples/readUDP/main.cpp

@@ -0,0 +1,61 @@
+#include <boost/asio.hpp>
+#include <srs/format.hpp>
+#include <srs/srs.hpp>
+
+constexpr auto PORT = "11111";
+constexpr auto IP_ADDR = "localhost";
+constexpr auto INPUT_BUFFER_SIZE = 10000;
+namespace asio = boost::asio;
+using udp = asio::ip::udp;
+
+namespace
+{
+    auto create_socket_from_ip_port(asio::io_context& context, const std::string& ip_addr, const std::string& port)
+    {
+        auto resolver = udp::resolver{ context };
+        auto udp_endpoints = resolver.resolve(udp::v4(), ip_addr, port);
+        auto endpoint = *udp_endpoints.begin();
+        return udp::socket{ context, endpoint };
+    }
+
+} // namespace
+
+class MsgReceiver
+{
+  public:
+    explicit MsgReceiver(udp::socket socket)
+        : socket_{ std::move(socket) }
+    {
+    }
+
+    void listen()
+    {
+        socket_.async_receive(asio::buffer(msg_buffer_),
+                              [this](auto error_code, auto byte_read)
+                              {
+                                  auto msg = std::string_view{ msg_buffer_.data(), byte_read };
+                                  if (!error_code)
+                                  {
+                                      const auto& struct_data = msg_reader_.convert(msg);
+                                      fmt::print("{}\n", struct_data);
+                                  }
+                                  listen();
+                              });
+    }
+
+  private:
+    udp::socket socket_;
+    std::array<char, INPUT_BUFFER_SIZE> msg_buffer_{};
+    srs::ProtoMsgReader msg_reader_;
+};
+
+auto main() -> int
+{
+    auto io_context = asio::io_context{};
+
+    auto msg_receiver = MsgReceiver{ create_socket_from_ip_port(io_context, IP_ADDR, PORT) };
+    msg_receiver.listen();
+    io_context.run();
+
+    return 0;
+}