feat(nebula_ros): add json schema

.cspell.json

@@ -6,14 +6,26 @@
     "adctp",
     "Adctp",
     "AT",
+    "autosar",
     "block_id",
+    "Bpearl",
+    "calib",
+    "DHAVE",
+    "Difop",
     "extrinsics",
     "gprmc",
+    "gptp",
+    "Helios",
     "Hesai",
+    "Idat",
+    "ipaddr",
+    "manc",
     "memcpy",
     "mkdoxy",
+    "Msop",
     "nohup",
     "nproc",
+    "ntoa",
     "pandar",
     "PANDAR",
     "PANDARAT",
@@ -23,13 +35,15 @@
     "QT",
     "rclcpp",
     "schedutil",
+    "srvs",
     "STD_COUT",
     "stds",
     "struct",
     "structs",
     "UDP_SEQ",
     "vccint",
     "Vccint",
+    "Vdat",
     "XT",
     "XTM",
     "DHAVE",
@@ -49,4 +63,4 @@
     "Piyush",
     "fout"
   ]
-}
+}

.github/workflows/json-schema-check.yaml

@@ -0,0 +1,40 @@
+name: json-schema-check
+
+on:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  check-if-relevant-files-changed:
+    runs-on: ubuntu-latest
+    outputs:
+      run-check: ${{ steps.paths_filter.outputs.json_or_yaml }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dorny/paths-filter@v3
+        id: paths_filter
+        with:
+          filters: |
+            json_or_yaml:
+              - '**/schema/*.schema.json'
+              - '**/schema/sub/.json'
+              - '**/config/**/*.param.yaml'
+
+  json-schema-check:
+    needs: check-if-relevant-files-changed
+    if: needs.check-if-relevant-files-changed.outputs.run-check == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Run json-schema-check
+        uses: autowarefoundation/autoware-github-actions/json-schema-check@v1
+
+  no-relevant-changes:
+    needs: check-if-relevant-files-changed
+    if: needs.check-if-relevant-files-changed.outputs.run-check == 'false'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Dummy step
+        run: echo "No relevant changes, passing check"

build_depends.repos

@@ -2,5 +2,5 @@ repositories:
   # TCP version of transport drivers
   transport_drivers:
     type: git
-    url: https://github.com/MapIV/transport_drivers
-    version: boost
+    url: https://github.com/mojomex/transport_drivers
+    version: mutable-buffer-in-udp-callback

nebula_common/CMakeLists.txt

@@ -40,6 +40,8 @@ ament_auto_add_library(nebula_common SHARED
         src/velodyne/velodyne_calibration_decoder.cpp
         )
 
+target_link_libraries(nebula_common yaml-cpp)
+
 ament_auto_package()
 
 # Set ROS_DISTRO macros

nebula_common/include/nebula_common/hesai/hesai_common.hpp

@@ -14,7 +14,7 @@ namespace nebula
 namespace drivers
 {
 /// @brief struct for Hesai sensor configuration
-struct HesaiSensorConfiguration : LidarConfigurationBase
+struct HesaiSensorConfiguration : public LidarConfigurationBase
 {
   uint16_t gnss_port{};
   double scan_phase{};
@@ -43,13 +43,20 @@ inline std::ostream & operator<<(std::ostream & os, HesaiSensorConfiguration con
   return os;
 }
 
+struct HesaiCalibrationConfigurationBase : public CalibrationConfigurationBase
+{
+  virtual nebula::Status LoadFromBytes(const std::vector<uint8_t> & buf) = 0;
+  virtual nebula::Status LoadFromFile(const std::string & calibration_file) = 0;
+  virtual nebula::Status SaveToFileFromBytes(const std::string & calibration_file, const std::vector<uint8_t> & buf) = 0;
+};
+
 /// @brief struct for Hesai calibration configuration
-struct HesaiCalibrationConfiguration : CalibrationConfigurationBase
+struct HesaiCalibrationConfiguration : public HesaiCalibrationConfigurationBase
 {
   std::map<size_t, float> elev_angle_map;
   std::map<size_t, float> azimuth_offset_map;
 
-  inline nebula::Status LoadFromFile(const std::string & calibration_file)
+  inline nebula::Status LoadFromFile(const std::string & calibration_file) override
   {
     std::ifstream ifs(calibration_file);
     if (!ifs) {
@@ -61,6 +68,11 @@ struct HesaiCalibrationConfiguration : CalibrationConfigurationBase
     return LoadFromString(ss.str());
   }
 
+  nebula::Status LoadFromBytes(const std::vector<uint8_t> & buf) {
+    std::string calibration_string = std::string(buf.begin(), buf.end());
+    return LoadFromString(calibration_string);
+  }
+
   /// @brief Loading calibration data
   /// @param calibration_content
   /// @return Resulting status
@@ -99,7 +111,7 @@ struct HesaiCalibrationConfiguration : CalibrationConfigurationBase
   /// @brief Saving calibration data (not used)
   /// @param calibration_file
   /// @return Resulting status
-  inline nebula::Status SaveFile(const std::string & calibration_file)
+  inline nebula::Status SaveToFile(const std::string & calibration_file)
   {
     std::ofstream ofs(calibration_file);
     if (!ofs) {
@@ -117,6 +129,11 @@ struct HesaiCalibrationConfiguration : CalibrationConfigurationBase
     return Status::OK;
   }
 
+  nebula::Status SaveToFileFromBytes(const std::string & calibration_file, const std::vector<uint8_t> & buf) override {
+    std::string calibration_string = std::string(buf.begin(), buf.end());
+    return SaveFileFromString(calibration_file, calibration_string);
+  }
+
   /// @brief Saving calibration data from string
   /// @param calibration_file path
   /// @param calibration_string calibration string
@@ -134,7 +151,7 @@ struct HesaiCalibrationConfiguration : CalibrationConfigurationBase
 };
 
 /// @brief struct for Hesai correction configuration (for AT)
-struct HesaiCorrection
+struct HesaiCorrection : public HesaiCalibrationConfigurationBase
 {
   uint16_t delimiter;
   uint8_t versionMajor;
@@ -156,7 +173,7 @@ struct HesaiCorrection
   /// @brief Load correction data from file
   /// @param buf Binary buffer
   /// @return Resulting status
-  inline nebula::Status LoadFromBinary(const std::vector<uint8_t> & buf)
+  inline nebula::Status LoadFromBytes(const std::vector<uint8_t> & buf) override
   {
     size_t index;
     for (index = 0; index < buf.size()-1; index++) {
@@ -258,7 +275,7 @@ struct HesaiCorrection
   /// @brief Load correction data from file
   /// @param correction_file path
   /// @return Resulting status
-  inline nebula::Status LoadFromFile(const std::string & correction_file)
+  inline nebula::Status LoadFromFile(const std::string & correction_file) override
   {
     std::ifstream ifs(correction_file, std::ios::in | std::ios::binary);
     if (!ifs) {
@@ -271,7 +288,7 @@ struct HesaiCorrection
       ifs.read((char *)&c, sizeof(unsigned char));
       buf.emplace_back(c);
     }
-    LoadFromBinary(buf);
+    LoadFromBytes(buf);
 
     ifs.close();
     return Status::OK;
@@ -281,7 +298,7 @@ struct HesaiCorrection
   /// @param correction_file path
   /// @param buf correction binary
   /// @return Resulting status
-  inline nebula::Status SaveFileFromBinary(const std::string & correction_file, const std::vector<uint8_t> & buf)
+  inline nebula::Status SaveToFileFromBytes(const std::string & correction_file, const std::vector<uint8_t> & buf) override
   {
     std::cerr << "Saving in:" << correction_file << "\n";
     std::ofstream ofs(correction_file, std::ios::trunc | std::ios::binary);

nebula_common/include/nebula_common/nebula_common.hpp

@@ -346,7 +346,7 @@ enum class PtpProfile {
   IEEE_1588v2 = 0,
   IEEE_802_1AS,
   IEEE_802_1AS_AUTO,
-  PROFILE_UNKNOWN
+  UNKNOWN_PROFILE
 };
 
 enum class PtpTransportType {
@@ -624,7 +624,7 @@ inline PtpProfile PtpProfileFromString(const std::string & ptp_profile)
   if (tmp_str == "802.1as") return PtpProfile::IEEE_802_1AS;
   if (tmp_str == "automotive") return PtpProfile::IEEE_802_1AS_AUTO;
 
-  return PtpProfile::PROFILE_UNKNOWN;
+  return PtpProfile::UNKNOWN_PROFILE;
 }
 
 /// @brief Convert PtpProfile enum to string (Overloading the << operator)
@@ -643,7 +643,7 @@ inline std::ostream & operator<<(std::ostream & os, nebula::drivers::PtpProfile
     case PtpProfile::IEEE_802_1AS_AUTO:
       os << "IEEE_802.1AS Automotive";
       break;
-    case PtpProfile::PROFILE_UNKNOWN:
+    case PtpProfile::UNKNOWN_PROFILE:
       os << "UNKNOWN";
       break;
   }

nebula_decoders/include/nebula_decoders/nebula_decoders_hesai/decoders/angle_corrector.hpp

@@ -23,19 +23,11 @@ struct CorrectedAngleData
 
 /// @brief Handles angle correction for given azimuth/channel combinations, as well as trigonometry
 /// lookup tables
+template <typename CorrectionDataT>
 class AngleCorrector
 {
-protected:
-  const std::shared_ptr<HesaiCalibrationConfiguration> sensor_calibration_;
-  const std::shared_ptr<HesaiCorrection> sensor_correction_;
-
 public:
-  AngleCorrector(
-    const std::shared_ptr<HesaiCalibrationConfiguration> & sensor_calibration,
-    const std::shared_ptr<HesaiCorrection> & sensor_correction)
-  : sensor_calibration_(sensor_calibration), sensor_correction_(sensor_correction)
-  {
-  }
+  using correction_data_t = CorrectionDataT;
 
   /// @brief Get the corrected azimuth and elevation for a given block and channel, along with their
   /// sin/cos values.

nebula_decoders/include/nebula_decoders/nebula_decoders_hesai/decoders/angle_corrector_calibration_based.hpp

@@ -11,7 +11,7 @@ namespace drivers
 {
 
 template <size_t ChannelN, size_t AngleUnit>
-class AngleCorrectorCalibrationBased : public AngleCorrector
+class AngleCorrectorCalibrationBased : public AngleCorrector<HesaiCalibrationConfiguration>
 {
 private:
   static constexpr size_t MAX_AZIMUTH_LEN = 360 * AngleUnit;
@@ -27,18 +27,16 @@ class AngleCorrectorCalibrationBased : public AngleCorrector
 
 public:
   AngleCorrectorCalibrationBased(
-    const std::shared_ptr<HesaiCalibrationConfiguration> & sensor_calibration,
-    const std::shared_ptr<HesaiCorrection> & sensor_correction)
-  : AngleCorrector(sensor_calibration, sensor_correction)
+    const std::shared_ptr<const HesaiCalibrationConfiguration> & sensor_calibration)
   {
     if (sensor_calibration == nullptr) {
       throw std::runtime_error(
         "Cannot instantiate AngleCorrectorCalibrationBased without calibration data");
     }
 
     for (size_t channel_id = 0; channel_id < ChannelN; ++channel_id) {
-      float elevation_angle_deg = sensor_calibration->elev_angle_map[channel_id];
-      float azimuth_offset_deg = sensor_calibration->azimuth_offset_map[channel_id];
+      float elevation_angle_deg = sensor_calibration->elev_angle_map.at(channel_id);
+      float azimuth_offset_deg = sensor_calibration->azimuth_offset_map.at(channel_id);
 
       elevation_angle_rad_[channel_id] = deg2rad(elevation_angle_deg);
       azimuth_offset_rad_[channel_id] = deg2rad(azimuth_offset_deg);

nebula_decoders/include/nebula_decoders/nebula_decoders_hesai/decoders/angle_corrector_correction_based.hpp

@@ -13,10 +13,11 @@ namespace drivers
 {
 
 template <size_t ChannelN, size_t AngleUnit>
-class AngleCorrectorCorrectionBased : public AngleCorrector
+class AngleCorrectorCorrectionBased : public AngleCorrector<HesaiCorrection>
 {
 private:
   static constexpr size_t MAX_AZIMUTH_LENGTH = 360 * AngleUnit;
+  const std::shared_ptr<const HesaiCorrection> correction_;
   rclcpp::Logger logger_;
 
   std::array<float, MAX_AZIMUTH_LENGTH> cos_{};
@@ -31,26 +32,25 @@ class AngleCorrectorCorrectionBased : public AngleCorrector
     // * none of the startFrames are defined as > 360 deg (< 0 not possible since they are unsigned)
     // * the fields are arranged in ascending order (e.g. field 1: 20-140deg, field 2: 140-260deg etc.)
     // These assumptions hold for AT128E2X.
-    int field = sensor_correction_->frameNumber - 1;
-    for (size_t i = 0; i < sensor_correction_->frameNumber; ++i) {
-      if (azimuth < sensor_correction_->startFrame[i]) return field;
+    int field = correction_->frameNumber - 1;
+    for (size_t i = 0; i < correction_->frameNumber; ++i) {
+      if (azimuth < correction_->startFrame[i]) return field;
       field = i;
     }
 
-    // This is never reached if sensor_correction_ is correct
+    // This is never reached if correction_ is correct
     return field;
   }
 
 public:
   AngleCorrectorCorrectionBased(
-    const std::shared_ptr<HesaiCalibrationConfiguration> & sensor_calibration,
-    const std::shared_ptr<HesaiCorrection> & sensor_correction)
-  : AngleCorrector(sensor_calibration, sensor_correction),
+    const std::shared_ptr<const HesaiCorrection> & sensor_correction)
+  : correction_(sensor_correction),
     logger_(rclcpp::get_logger("AngleCorrectorCorrectionBased"))
   {
     if (sensor_correction == nullptr) {
       throw std::runtime_error(
-        "Cannot instantiate AngleCorrectorCalibrationBased without calibration data");
+        "Cannot instantiate AngleCorrectorCorrectionBased without correction data");
     }
 
     logger_.set_level(rclcpp::Logger::Level::Debug);
@@ -64,17 +64,16 @@ class AngleCorrectorCorrectionBased : public AngleCorrector
 
   CorrectedAngleData getCorrectedAngleData(uint32_t block_azimuth, uint32_t channel_id) override
   {
-    const auto & correction = AngleCorrector::sensor_correction_;
     int field = findField(block_azimuth);
 
     auto elevation =
-      correction->elevation[channel_id] +
-      correction->getElevationAdjustV3(channel_id, block_azimuth) * (AngleUnit / 100);
+      correction_->elevation[channel_id] +
+      correction_->getElevationAdjustV3(channel_id, block_azimuth) * (AngleUnit / 100);
     elevation = (MAX_AZIMUTH_LENGTH + elevation) % MAX_AZIMUTH_LENGTH;
 
-    auto azimuth = (block_azimuth + MAX_AZIMUTH_LENGTH - correction->startFrame[field]) * 2 -
-                   correction->azimuth[channel_id] +
-                   correction->getAzimuthAdjustV3(channel_id, block_azimuth) * (AngleUnit / 100);
+    auto azimuth = (block_azimuth + MAX_AZIMUTH_LENGTH - correction_->startFrame[field]) * 2 -
+                   correction_->azimuth[channel_id] +
+                   correction_->getAzimuthAdjustV3(channel_id, block_azimuth) * (AngleUnit / 100);
     azimuth = (MAX_AZIMUTH_LENGTH + azimuth) % MAX_AZIMUTH_LENGTH;
 
     float azimuth_rad = 2.f * azimuth * M_PI / MAX_AZIMUTH_LENGTH;