tmc51x0_daisy_chain.hpp

Go to the documentation of this file.

 
#pragma once
#include <array>
#include <cstdint>
#include <optional>
 
#include "../tmc51x0.hpp"
#include "../tmc51x0_comm_interface.hpp"
 
namespace tmc51x0 {
 
template <typename CommType, size_t MaxDevices = 8> class TMC51x0DaisyChain {
public:
  explicit TMC51x0DaisyChain(CommType &comm, uint8_t num_onboard_devices,
                             uint32_t f_clk = ClockFreq::DEFAULT_F_CLK) noexcept
      : comm_(comm), num_onboard_devices_(num_onboard_devices),
        num_active_devices_(num_onboard_devices) {
    (void)f_clk;
    // Validate num_onboard_devices
    if (num_onboard_devices == 0 || num_onboard_devices > MaxDevices) {
      num_onboard_devices_ = 1;
      num_active_devices_ = 1;
    }
 
    // Create onboard TMC51x0 instances, one per device
    // Each device has its position (0, 1, 2, ...) set in constructor
    for (uint8_t i = 0; i < num_onboard_devices_; ++i) {
      drivers_[i].emplace(comm_, i); // TMC51x0(comm, daisy_chain_position)
    }
 
    // Initialize extra device slots as empty
    for (size_t i = num_onboard_devices_; i < MaxDevices; ++i) {
      drivers_[i].reset();
    }
 
    // CRITICAL: Set the total chain length on the SpiCommInterface
    // This enables proper response extraction using datasheet formula
    // 40·(n-k+1)
    UpdateChainLength();
  }
 
  [[nodiscard]] uint8_t GetNumOnboardDevices() const noexcept {
    return num_onboard_devices_;
  }
 
  [[nodiscard]] uint8_t GetNumActiveDevices() const noexcept {
    return num_active_devices_;
  }
 
  [[nodiscard]] constexpr size_t GetMaxCapacity() const noexcept {
    return MaxDevices;
  }
 
  [[nodiscard]] bool IsDeviceActive(uint8_t index) const noexcept {
    if (index >= MaxDevices) {
      return false;
    }
    return drivers_[index].has_value();
  }
 
  Result<void> AddDevice(uint8_t position) noexcept {
    // Validate position
    if (position < num_onboard_devices_ || position >= MaxDevices) {
      return Result<void>(ErrorCode::INVALID_VALUE);
    }
 
    // Check if slot is already occupied
    if (drivers_[position].has_value()) {
      return Result<void>(ErrorCode::INVALID_STATE);
    }
 
    // Enforce sequential positioning: cannot skip positions
    // All positions before this one (starting from num_onboard_devices) must be
    // filled
    for (uint8_t i = num_onboard_devices_; i < position; ++i) {
      if (!drivers_[i].has_value()) {
        return Result<void>(
            ErrorCode::INVALID_STATE); // Cannot skip positions in daisy chain
      }
    }
 
    // Create device instance at specified position
    drivers_[position].emplace(comm_, position);
    num_active_devices_++;
 
    // Update chain length on SpiCommInterface
    UpdateChainLength();
 
    return Result<void>();
  }
 
  Result<void> RemoveDevice(uint8_t position) noexcept {
    // Cannot remove onboard devices
    if (position < num_onboard_devices_) {
      return Result<void>(ErrorCode::INVALID_VALUE);
    }
 
    // Validate position
    if (position >= MaxDevices) {
      return Result<void>(ErrorCode::INVALID_VALUE);
    }
 
    // Check if slot is actually active
    if (!drivers_[position].has_value()) {
      return Result<void>(ErrorCode::INVALID_STATE);
    }
 
    // Enforce sequential removal: can only remove from the end
    // Check if there are any devices after this position
    for (size_t i = position + 1; i < MaxDevices; ++i) {
      if (drivers_[i].has_value()) {
        return Result<void>(
            ErrorCode::INVALID_STATE); // Cannot remove device in the middle of
                                       // the chain
      }
    }
 
    // Remove device
    drivers_[position].reset();
    num_active_devices_--;
 
    // Update chain length on SpiCommInterface
    UpdateChainLength();
 
    return Result<void>();
  }
 
  [[nodiscard]] TMC51x0<CommType> &operator[](uint8_t index) noexcept {
    return drivers_[index].value();
  }
 
  [[nodiscard]] const TMC51x0<CommType> &
  operator[](uint8_t index) const noexcept {
    return drivers_[index].value();
  }
 
  Result<void>
  InitializeAll(const DriverConfig &config = DriverConfig()) noexcept {
    for (size_t i = 0; i < MaxDevices; ++i) {
      if (drivers_[i].has_value()) {
        auto result = drivers_[i]->Initialize(config);
        if (!result) {
          return result; // Return first error
        }
      }
    }
    return Result<void>();
  }
 
private:
  void UpdateChainLength() noexcept {
    // Find the highest active device position
    uint8_t max_position = 0;
    for (size_t i = 0; i < MaxDevices; ++i) {
      if (drivers_[i].has_value()) {
        max_position = static_cast<uint8_t>(i);
      }
    }
 
    // Total chain length is max_position + 1 (0-indexed to 1-indexed)
    uint8_t total_length = max_position + 1;
    comm_.SetDaisyChainLength(total_length);
  }
 
  CommType &comm_;              
  uint8_t num_onboard_devices_; 
  uint8_t
      num_active_devices_; 
  std::array<std::optional<TMC51x0<CommType>>, MaxDevices>
      drivers_; 
};
 
} // namespace tmc51x0