HPO handling first-pass implementation

sygnal_can_interface/sygnal_can_interface_lib/CMakeLists.txt

@@ -32,6 +32,7 @@ add_library(
   src/crc8.cpp
   src/sygnal_mcm_interface.cpp
   src/sygnal_command_interface.cpp
+  src/sygnal_hpo_interface.cpp
   src/sygnal_interface_socketcan.cpp
 )
 
@@ -108,6 +109,22 @@ if(BUILD_TESTING)
     WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
   )
 
+  add_executable(sygnal_hpo_interface_tests
+    test/sygnal_hpo_interface_test.cpp
+  )
+  target_link_libraries(sygnal_hpo_interface_tests
+    PRIVATE ${PROJECT_NAME} sygnal_dbc::sygnal_dbc Catch2::Catch2WithMain
+  )
+  ament_add_test(
+    sygnal_hpo_interface_tests
+    GENERATE_RESULT_FOR_RETURN_CODE_ZERO
+    COMMAND "$<TARGET_FILE:sygnal_hpo_interface_tests>"
+      -r junit -s
+      -o test_results/${PROJECT_NAME}/sygnal_hpo_interface_tests_output.xml
+    ENV CATCH_CONFIG_CONSOLE_WIDTH=120
+    WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
+  )
+
   if(DEFINED ENV{CAN_AVAILABLE})
     add_executable(sygnal_interface_socketcan_tests
       test/sygnal_interface_socketcan_test.cpp

sygnal_can_interface/sygnal_can_interface_lib/include/sygnal_can_interface_lib/sygnal_hpo_interface.hpp

@@ -0,0 +1,133 @@
+// Copyright (c) 2025-present Polymath Robotics, Inc. All rights reserved
+//
+// 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.
+
+#ifndef SYGNAL_CAN_INTERFACE_LIB__SYGNAL_HPO_INTERFACE_HPP_
+#define SYGNAL_CAN_INTERFACE_LIB__SYGNAL_HPO_INTERFACE_HPP_
+
+#include <array>
+#include <chrono>
+#include <optional>
+#include <string>
+
+#include "socketcan_adapter/can_frame.hpp"
+
+namespace polymath::sygnal
+{
+
+constexpr uint8_t HPO_NUM_INTERFACES = 7;
+
+/// @brief Parsed HPO ControlEnableResponse / ControlCommandResponse.
+///        is_enable_response disambiguates which payload is meaningful:
+///        when true, the `enable` field carries the response; when false,
+///        the `value` field carries the float command response.
+struct HpoControlResponse
+{
+  uint8_t message_id;
+  uint8_t bus_address;
+  double value;
+  bool enable;
+  bool is_enable_response;
+};
+
+/// @brief Parsed HPO ErrorStatus frame fields.
+struct HpoErrorStatus
+{
+  uint8_t bus_address;
+  uint8_t subsystem_id;
+  uint8_t error_type;
+  uint16_t error_can_id;
+  uint8_t config_section_id;
+  uint8_t config_interface_id;
+};
+
+/// @brief Self-contained HPO board representation.
+///
+/// Owns the per-device interface bits (7 per-interface + 1 overall) and produces /
+/// consumes the CAN frames the HPO understands. Frames are routed to the right
+/// instance by `bus_address_`: every parse helper rejects frames that do not match
+/// this device's bus address. Command frames are populated with `bus_address_`
+/// automatically so callers cannot mismatch addresses.
+///
+/// Unlike the MCM, the HPO does not hold a Sygnal state machine. The per-interface
+/// and overall-interface heartbeat signals are 1-bit booleans (true = HPO in control,
+/// false = released). The MCM's SystemState byte is not tracked here.
+class SygnalHpoInterface
+{
+public:
+  SygnalHpoInterface();
+  explicit SygnalHpoInterface(uint8_t bus_address);
+  ~SygnalHpoInterface() = default;
+
+  /// @brief Try to parse a CAN frame as an HPO heartbeat addressed to this device.
+  /// @param frame Raw CAN frame.
+  /// @return true if the frame matched and internal state was updated.
+  bool parseHeartbeatFrame(const socketcan::CanFrame & frame);
+
+  /// @brief Try to parse a CAN frame as a ControlEnableResponse or ControlCommandResponse
+  ///        addressed to this device.
+  /// @param frame Raw CAN frame.
+  /// @return Populated HpoControlResponse on success, std::nullopt otherwise.
+  std::optional<HpoControlResponse> parseControlResponse(const socketcan::CanFrame & frame);
+
+  /// @brief Try to parse a CAN frame as an ErrorStatus addressed to this device.
+  /// @param frame Raw CAN frame.
+  /// @return Populated HpoErrorStatus on success, std::nullopt otherwise.
+  std::optional<HpoErrorStatus> parseErrorFrame(const socketcan::CanFrame & frame);
+
+  /// @brief Build a ControlEnable frame for this device.
+  /// @param message_id 8-bit HPO MessageID.
+  /// @param enable true to grant HPO control, false to release.
+  /// @param[out] error_message Populated on failure.
+  /// @return Packed CAN frame on success.
+  std::optional<socketcan::CanFrame> createControlEnableFrame(
+    uint8_t message_id, bool enable, std::string & error_message);
+
+  /// @brief Build a ControlCommand frame for this device.
+  /// @param message_id 8-bit HPO MessageID.
+  /// @param value Command value (encoded as float per the DBC).
+  /// @param[out] error_message Populated on failure.
+  /// @return Packed CAN frame on success.
+  std::optional<socketcan::CanFrame> createControlCommandFrame(
+    uint8_t message_id, double value, std::string & error_message);
+
+  uint8_t get_bus_address() const
+  {
+    return bus_address_;
+  }
+
+  std::array<bool, HPO_NUM_INTERFACES> get_interface_states() const
+  {
+    return hpo_interface_states_;
+  }
+
+  bool get_overall_interface_state() const
+  {
+    return hpo_overall_interface_state_;
+  }
+
+  std::chrono::system_clock::time_point get_last_heartbeat_timestamp() const
+  {
+    return last_heartbeat_timestamp_;
+  }
+
+private:
+  uint8_t bus_address_;
+  std::array<bool, HPO_NUM_INTERFACES> hpo_interface_states_;
+  bool hpo_overall_interface_state_;
+  std::chrono::system_clock::time_point last_heartbeat_timestamp_;
+};
+
+}  // namespace polymath::sygnal
+
+#endif  // SYGNAL_CAN_INTERFACE_LIB__SYGNAL_HPO_INTERFACE_HPP_