feat: support Aeva Aeries II

.cspell.json

@@ -5,6 +5,7 @@
   "words": [
     "adctp",
     "Adctp",
+    "aeva",
     "applicate",
     "AT",
     "autosar",
@@ -21,6 +22,7 @@
     "gptp",
     "Helios",
     "Hesai",
+    "hfov",
     "horiz",
     "Idat",
     "ipaddr",

docs/parameters/vendors/aeva/aeries2.md

@@ -0,0 +1 @@
+{{ json_to_markdown("nebula_ros/schema/Aeries2.schema.json") }}

docs/point_types.md

@@ -20,6 +20,22 @@ These definitions can be found in the `nebula_common/include/point_types.hpp`.
 | `distance`    | `float`  | `m`   | Distance from the sensor origin.                        |
 | `timestamp`   | `uint32` | `ns`  | Time of detection relative to the pointcloud timestamp. |
 
+## PointXYZVIRCAEDT
+
+| Field           | Type     | Units | Description                                                                 |
+| --------------- | -------- | ----- | --------------------------------------------------------------------------- |
+| `x`             | `float`  | `m`   | The point's cartesian x coordinate.                                         |
+| `y`             | `float`  | `m`   | The point's cartesian y coordinate.                                         |
+| `z`             | `float`  | `m`   | The point's cartesian z coordinate.                                         |
+| `distance_rate` | `float`  | `m/s` | The point's velocity component in the direction of the sensor's origin.     |
+| `intensity`     | `uint8`  |       | The intensity of the return as reported by the sensor.                      |
+| `return type`   | `uint8`  |       | Whether the point was the first, strongest, last, etc. of multiple returns. |
+| `channel`       | `uint16` |       | The ID of the laser channel that produced the point.                        |
+| `azimuth`       | `float`  | `rad` | The point's azimuth in polar coordinates.                                   |
+| `elevation`     | `float`  | `rad` | The point's elevation in polar coordinates.                                 |
+| `distance`      | `float`  | `m`   | The point's distance from the sensor origin.                                |
+| `timestamp`     | `uint32` | `ns`  | The time the point was detected relative to the pointcloud timestamp.       |
+
 ## [Deprecated] PointXYZIR
 
 | Field       | Type     | Units | Description                                        |

docs/supported_sensors.md

@@ -41,6 +41,14 @@ The `sensor_model` parameter below decides which sensor driver is launched.
 | Bpearl | Bpearl         | Bpearl.param.yaml  | ⚠️          |
 | Helios | Helios         | Helios.param.yaml  | ⚠️          |
 
+## Aeva LiDARs
+
+| Model     | `sensor_model` | Configuration file | Test status |
+| --------- | -------------- | ------------------ | ----------- |
+| Aeries II | Aeries2        | Aeries2.param.yaml | ⚠️\*        |
+
+\*: The Aeries II has been tested with firmware version 14.0.0.
+
 ## Continental radars
 
 | Model  | `sensor_model` | Configuration file | Test status |

mkdocs.yml

@@ -63,6 +63,8 @@ nav:
           - parameters/vendors/continental/common.md
           - ARS548: parameters/vendors/continental/ars548.md
           - SRR520: parameters/vendors/continental/srr520.md
+      - Aeva:
+          - Aeries II: parameters/vendors/aeva/aeries2.md
   - Point cloud types: point_types.md
   - Design: design.md
   - Tutorials: tutorials.md

nebula_common/CMakeLists.txt

@@ -4,7 +4,7 @@ project(nebula_common)
 find_package(ament_cmake_auto REQUIRED)
 find_package(PCL REQUIRED COMPONENTS common)
 find_package(yaml-cpp REQUIRED)
-find_package(nlohmann_json REQUIRED)
+find_package(nlohmann_json 3.10.5 REQUIRED)
 
 # Default to C++17
 if (NOT CMAKE_CXX_STANDARD)

nebula_common/include/nebula_common/aeva/config_types.hpp

@@ -0,0 +1,67 @@
+// Copyright 2024 TIER IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "nebula_common/nebula_common.hpp"
+#include "nebula_common/util/parsing.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <optional>
+#include <ostream>
+#include <string>
+
+namespace nebula::drivers::aeva
+{
+
+using nlohmann::json;
+
+struct Aeries2Config : public SensorConfigurationBase
+{
+  std::string sensor_ip;
+  json tree;
+
+  [[nodiscard]] std::optional<ReturnMode> get_return_mode() const
+  {
+    auto mode_name = util::get_if_exists<std::string>(tree, {"dsp_control", "second_peak_type"});
+
+    if (!mode_name) return {};
+    if (mode_name == "strongest") return ReturnMode::DUAL_STRONGEST_SECONDSTRONGEST;
+    if (mode_name == "farthest") return ReturnMode::DUAL_STRONGEST_LAST;
+    if (mode_name == "closest") return ReturnMode::DUAL_STRONGEST_FIRST;
+
+    return ReturnMode::UNKNOWN;
+  }
+
+  friend std::ostream & operator<<(std::ostream & os, const Aeries2Config & arg)
+  {
+    os << "Aeva Aeries II Sensor Configuration:\n";
+    os << "Sensor Model: " << arg.sensor_model << '\n';
+    os << "Frame ID: " << arg.frame_id << '\n';
+    os << "Sensor IP: " << arg.sensor_ip;
+
+    for (const auto & category : arg.tree.items()) {
+      os << '\n' << category.key() << ":";
+      auto category_settings = category.value();
+      for (const auto & setting : category_settings.items()) {
+        os << "\n  " << setting.key() << ": " << setting.value();
+      }
+    }
+
+    return os;
+  }
+};
+
+}  // namespace nebula::drivers::aeva

nebula_common/include/nebula_common/aeva/packet_types.hpp

@@ -0,0 +1,196 @@
+// Copyright 2024 TIER IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <nlohmann/json.hpp>
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <ostream>
+#include <string>
+#include <vector>
+
+namespace nebula::drivers::aeva
+{
+using nlohmann::json;
+
+#pragma pack(push, 1)
+
+template <typename storage_t, size_t n_fractional_bits>
+struct FixedPoint
+{
+  [[nodiscard]] float value() const { return value_ * std::pow(2., -1. * n_fractional_bits); }
+
+private:
+  storage_t value_;
+};
+
+template <size_t n_bytes>
+struct Padding
+{
+  uint8_t padding[n_bytes];  // NOLINT
+};
+
+struct SomeIpHeader
+{
+  uint16_t service_id;
+  uint16_t method_id;
+  uint32_t message_length;
+  uint16_t client_id;
+  uint16_t session_id;
+  uint8_t protocol;
+  uint8_t interface_version;
+  uint8_t message_type;
+  uint8_t return_code;
+  uint32_t tp_header_offset : 28;
+  uint32_t tp_header : 4;
+};
+
+struct MessageHeader
+{
+  uint8_t major_version : 4;
+  uint8_t minor_version : 4;
+  uint8_t message_type;
+  uint16_t sequence_id;
+  uint32_t message_length;
+  int64_t acquisition_time_ns;
+  int64_t publish_time_ns;
+};
+
+struct PointcloudMsgSubheaderAndMetadata
+{
+  uint16_t aeva_marker;
+  uint8_t platform;
+  uint8_t reserved_1;
+  uint16_t ns_per_index;
+  uint64_t first_point_timestamp_ns;
+  int32_t frame_sync_index;
+  uint32_t period_ns;
+  uint32_t n_entries;
+  uint32_t capacity;
+  uint16_t num_beams : 4;
+  uint16_t num_peaks : 2;
+  uint16_t range_scale : 10;
+  uint8_t line_index;
+  uint8_t max_line_index;
+  uint32_t face_index : 4;
+  uint32_t n_faces : 4;
+  uint32_t reserved_2 : 3;
+  uint32_t sensitivity_mode : 3;
+  uint32_t frame_parity : 1;
+  uint32_t reserved_3 : 1;
+  uint32_t window_measurement : 1;
+  uint32_t reserved_5 : 1;
+  uint32_t discard_line : 1;
+  uint32_t ping_pong : 1;
+  uint32_t reserved_6 : 12;
+  FixedPoint<int16_t, 9> mirror_rps;
+  uint16_t dither_step : 5;
+  uint16_t max_dither_step : 5;
+  uint16_t reserved_7 : 6;
+  uint8_t reserved_8[12];
+};
+
+struct PointCloudPoint
+{
+  FixedPoint<int16_t, 15> azimuth;
+  FixedPoint<int16_t, 15> elevation;
+  FixedPoint<uint16_t, 7> range;
+  FixedPoint<int16_t, 8> velocity;
+  uint8_t intensity;
+  uint8_t signal_quality;
+  uint32_t beam_id : 3;
+  uint32_t peak_id : 2;
+  uint32_t line_transition : 1;
+  uint32_t valid : 1;
+  uint32_t dynamic : 1;
+  uint32_t reserved_1 : 1;
+  uint32_t up_sweep : 1;
+  uint32_t in_ambiguity_region : 1;
+  uint32_t reserved_2 : 9;
+  uint32_t peak_width : 4;
+  uint32_t is_single_detection : 1;
+  uint32_t reserved_3 : 7;
+};
+
+struct PointCloudMessage
+{
+  PointcloudMsgSubheaderAndMetadata header;
+  std::vector<PointCloudPoint> points;
+};
+
+enum class TelemetryDataType : uint8_t {
+  kUInt8 = 0,
+  kInt8 = 1,
+  kUInt16 = 2,
+  kInt16 = 3,
+  kUInt32 = 4,
+  kInt32 = 5,
+  kUInt64 = 6,
+  kInt64 = 7,
+  kFloat = 8,
+  kDouble = 9,
+  kChar = 10
+};
+
+enum class ReconfigRequestType : uint8_t {
+  kManifestRequest = 0,
+  kManifestResponse = 1,
+  kChangeRequest = 2,
+  kChangeApproved = 3,
+  kChangeIgnored = 4,
+  kInvalid = 5
+};
+
+inline std::ostream & operator<<(std::ostream & os, const ReconfigRequestType & arg)
+{
+  switch (arg) {
+    case ReconfigRequestType::kManifestRequest:
+      return os << "manifest request";
+    case ReconfigRequestType::kManifestResponse:
+      return os << "manifest response";
+    case ReconfigRequestType::kChangeRequest:
+      return os << "change request";
+    case ReconfigRequestType::kChangeApproved:
+      return os << "change approved";
+    case ReconfigRequestType::kChangeIgnored:
+      return os << "change ignored";
+    default:
+      return os << "invalid: " + std::to_string(static_cast<int>(arg));
+  }
+}
+
+struct HealthCode
+{
+  explicit HealthCode(uint32_t value) : value_(value) {}
+
+  [[nodiscard]] bool is_error() const { return (value_ & g_error_mask) != 0; }
+  [[nodiscard]] uint32_t get() const { return value_ & ~g_error_mask; }
+
+private:
+  uint32_t value_;
+  static const uint32_t g_error_mask = 1u << 31u;
+};
+
+struct ReconfigMessage
+{
+  ReconfigRequestType type = ReconfigRequestType::kInvalid;
+  std::optional<json> body;
+};
+
+#pragma pack(pop)
+
+}  // namespace nebula::drivers::aeva

nebula_common/include/nebula_common/aeva/point_types.hpp

@@ -0,0 +1,46 @@
+// Copyright 2024 TIER IV, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <pcl/point_types.h>
+
+namespace nebula::drivers::aeva
+{
+
+struct EIGEN_ALIGN16 PointXYZVIRCAEDT
+{
+  float x;
+  float y;
+  float z;
+  float range_rate;
+  uint8_t intensity;
+  uint8_t return_type;
+  uint16_t channel;
+  float azimuth;
+  float elevation;
+  float distance;
+  uint32_t time_stamp;
+  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
+};
+
+}  // namespace nebula::drivers::aeva
+
+POINT_CLOUD_REGISTER_POINT_STRUCT(  // NOLINT
+  nebula::drivers::aeva::PointXYZVIRCAEDT,
+  (float, x,
+   x)(float, y, y)(float, z, z)(float, range_rate, range_rate)(std::uint8_t, intensity, intensity)(
+    std::uint8_t, return_type,
+    return_type)(std::uint16_t, channel, channel)(float, azimuth, azimuth)(
+    float, elevation, elevation)(float, distance, distance)(std::uint32_t, time_stamp, time_stamp))