as5047u.hpp

Go to the documentation of this file.

 
#pragma once
#include "as5047u_registers.hpp"
#include "as5047u_spi_interface.hpp"
#include "as5047u_version.h"
#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <cstdint>
#include <cstdio>     // for printf in DumpStatus()
#include <functional> // for std::function
#include <utility>    // for std::pair
 
// Error flags: bits 0-10 are the ERRFL register (datasheet Figure 33); bits 11-15, which ERRFL does
// not use, are errors the driver detects itself.
enum class AS5047U_Error : uint16_t {
  None = 0,
  AgcWarning = 1 << 0,      
  MagHalf = 1 << 1,         
  P2ramWarning = 1 << 2,    
  P2ramError = 1 << 3,      
  FramingError = 1 << 4,    
  CommandError = 1 << 5,    
  CrcError = 1 << 6,        
  WatchdogError = 1 << 7,   
  OffCompError = 1 << 9,    
  CordicOverflow = 1 << 10, 
  BusError = 1 << 11,       
  ReplyCrcError = 1 << 12,  
  ReplyWarning = 1 << 13,   
  ReplyError = 1 << 14      
};
 
// -----------------------------------------------------------------------------
// Type definitions
// -----------------------------------------------------------------------------
#include "as5047u_types.hpp" // For FrameFormat enum
 
// -----------------------------------------------------------------------------
// Default configuration values
// -----------------------------------------------------------------------------
#include "as5047u_config.hpp" // defines AS5047U_CFG namespace with defaults
 
// -----------------------------------------------------------------------------
// as5047u Namespace
// -----------------------------------------------------------------------------
namespace as5047u {
 
inline constexpr std::size_t kOtpRegisterCount = 7;
inline constexpr uint16_t kOtpFirstAddress = 0x0015;
 
struct OtpResult {
  uint8_t failed_step = 0;
  bool burn_started = false;
  std::array<uint16_t, kOtpRegisterCount> written{};
};
 
inline constexpr float kPi = 3.14159265358979323846F;
 
enum class AngleUnit : uint8_t {
  Lsb,
  Degrees,
  Radians
};
 
enum class VelocityUnit : uint8_t {
  Lsb,
  DegPerSec,
  RadPerSec,
  Rpm
};
 
template <typename SpiType>
class AS5047U {
public:
  //------------------------------------------------------------------
  // Constructor and destructor
  //------------------------------------------------------------------
 
  explicit AS5047U(SpiType& bus, FrameFormat format = AS5047U_CFG::DEFAULT_FRAME_FORMAT) noexcept;
 
  ~AS5047U() = default;
 
  static constexpr uint8_t ComputeCRC8(uint16_t data16) {
    uint8_t crc = 0xC4;
    for (int i = 0; i < 16; ++i) {
      bool bit = ((data16 >> (15 - i)) & 1) ^ ((crc >> 7) & 1);
      crc = (crc << 1) ^ (bit ? 0x1D : 0x00);
    }
    return crc ^ 0xFF;
  }
 
  //------------------------------------------------------------------
  // High-level API
  //------------------------------------------------------------------
  void SetFrameFormat(FrameFormat format) noexcept;
 
  [[nodiscard]] uint16_t GetAngle(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  [[nodiscard]] float GetAngle(AngleUnit unit,
                               uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  [[nodiscard]] float GetAngleDegrees(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  [[nodiscard]] float GetAngleRadians(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  [[nodiscard]] uint16_t GetRawAngle(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  [[nodiscard]] int16_t GetVelocity(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  [[nodiscard]] float GetVelocity(VelocityUnit unit,
                                  uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  struct Angle {
    static constexpr float DEG_PER_LSB = 360.0F / 16384.0F;
    static constexpr float RAD_PER_LSB = (2.0F * kPi) / 16384.0F;
 
    static constexpr uint16_t DegreesToLsb(float degrees) noexcept {
      return static_cast<uint16_t>((degrees * 16384.0F) / 360.0F) & 0x3FFF;
    }
 
    static constexpr uint16_t RadiansToLsb(float radians) noexcept {
      return static_cast<uint16_t>((radians * 16384.0F) / (2.0F * kPi)) & 0x3FFF;
    }
  };
 
  struct Velocity {
    static constexpr float DEG_PER_LSB = 24.141F;
    static constexpr float RAD_PER_LSB = DEG_PER_LSB * kPi / 180.0F;
    static constexpr float RPM_PER_LSB = DEG_PER_LSB * (60.0F / 360.0F);
  };
 
  [[nodiscard]] float GetVelocityDegPerSec(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
  [[nodiscard]] float GetVelocityRadPerSec(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
  [[nodiscard]] float GetVelocityRPM(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  [[nodiscard]] uint8_t GetAGC(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  [[nodiscard]] uint16_t GetMagnitude(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  [[nodiscard]] uint16_t GetErrorFlags(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  void DumpStatus() const;
 
  [[nodiscard]] uint16_t GetZeroPosition(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  bool SetZeroPosition(uint16_t angle_lsb, uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  bool SetDirection(bool clockwise, uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  bool SetABIResolution(uint8_t resolution_bits, uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  bool SetUVWPolePairs(uint8_t pairs, uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  bool SetIndexPulseLength(uint8_t lsb_len, uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  bool ConfigureInterface(bool abi, bool uvw, bool pwm, uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  bool SetDynamicAngleCompensation(bool enable, uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  bool SetAdaptiveFilter(bool enable, uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  bool SetFilterPreset(FilterPreset preset,
                      uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  bool SetFilterParameters(uint8_t k_min, uint8_t k_max,
                           uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  [[nodiscard]] bool GetAdaptiveFilterEnabled(uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  [[nodiscard]] std::pair<uint8_t, uint8_t> GetFilterParameters(
      uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  bool Set150CTemperatureMode(bool enable, uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  bool ProgramOTP(OtpResult* result = nullptr);
 
  [[nodiscard]] bool VerifyOTP(const std::array<uint16_t, kOtpRegisterCount>& burned,
                               uint8_t retries = AS5047U_CFG::CRC_RETRIES) const;
 
  void SetPad(uint8_t pad) noexcept;
 
  bool SetHysteresis(AS5047U_REG::SETTINGS3::Hysteresis hysteresis,
                     uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  AS5047U_REG::SETTINGS3::Hysteresis GetHysteresis() const;
 
  bool SetAngleOutputSource(AS5047U_REG::SETTINGS2::AngleOutputSource source,
                            uint8_t retries = AS5047U_CFG::CRC_RETRIES);
 
  AS5047U_REG::SETTINGS2::AngleOutputSource GetAngleOutputSource() const;
 
  AS5047U_REG::DIA GetDiagnostics() const;
 
  template <typename RegT>
  RegT ReadReg() const {
    return decode<RegT>(readRegister(RegT::ADDRESS));
  }
 
  template <typename RegT>
  [[nodiscard]] bool ReadReg(RegT& reg, uint8_t retries = AS5047U_CFG::CRC_RETRIES) const {
    return readWithRetries(RegT::ADDRESS, retries, reg.value);
  }
 
  template <typename RegT>
  bool WriteReg(const RegT& reg, uint8_t retries = AS5047U_CFG::CRC_RETRIES) {
    return writeRegister(RegT::ADDRESS, encode(reg), retries);
  }
 
  [[nodiscard]] AS5047U_Error GetStickyErrorFlags() const noexcept;
 
  AS5047U_Error ClearStickyErrorFlags() noexcept;
 
  // ===========================================================================
  // Driver Version
  // ===========================================================================
 
  static constexpr const char* GetDriverVersion() noexcept {
    return HF_AS5047U_VERSION_STRING;
  }
 
  static constexpr uint8_t GetDriverVersionMajor() noexcept {
    return HF_AS5047U_VERSION_MAJOR;
  }
 
  static constexpr uint8_t GetDriverVersionMinor() noexcept {
    return HF_AS5047U_VERSION_MINOR;
  }
 
  static constexpr uint8_t GetDriverVersionPatch() noexcept {
    return HF_AS5047U_VERSION_PATCH;
  }
 
private:
  //------------------------------------------------------------------
  // Low-level helpers
  //------------------------------------------------------------------
  // Low level register access helpers
  static constexpr uint16_t kReadBit = 0x4000; 
  static constexpr uint16_t kReplyWarningBit = 0x8000; 
  static constexpr uint16_t kReplyErrorBit = 0x4000;   
 
  bool transferFrame(FrameFormat format, uint16_t word, uint16_t& reply,
                     bool inspect = false) const;
  bool rawReadRegister(uint16_t addr, uint16_t& value) const;
  bool readRegister(uint16_t addr, uint16_t& value) const;
  uint16_t readRegister(uint16_t addr) const; 
  bool readWithRetries(uint16_t addr, uint8_t retries, uint16_t& value) const;
  uint16_t readWithRetries(uint16_t addr, uint8_t retries) const;
  bool writeRegister(uint16_t addr, uint16_t val, uint8_t retries, bool verify = true) const;
  bool programOtpSteps(OtpResult& r);
  bool readOtpRegisters(std::array<uint16_t, kOtpRegisterCount>& regs, uint8_t retries) const;
  static constexpr uint32_t kOtpPollLimit = 15000; 
 
  static constexpr uint16_t kRetryMask = static_cast<uint16_t>(AS5047U_Error::CrcError) |
                                         static_cast<uint16_t>(AS5047U_Error::FramingError);
  static constexpr uint16_t kCommandErrorMask =
      kRetryMask | static_cast<uint16_t>(AS5047U_Error::CommandError);
 
  SpiType& spi_;             
  FrameFormat frame_format_; 
  uint8_t pad_byte_{0};      
 
  mutable std::atomic<uint16_t> sticky_errors_{0}; 
  void updateStickyErrors(uint16_t err_fl) const;
 
  // Helper functions implemented inline for templates
  template <typename RegT>
  static constexpr uint16_t encode(const RegT& r) {
    return r.value;
  }
 
  template <typename RegT>
  static constexpr RegT decode(uint16_t raw) {
    RegT r{};
    r.value = raw;
    return r;
  }
};
 
// Template member function definitions must be in header
template <typename SpiType>
AS5047U<SpiType>::AS5047U(SpiType& bus, FrameFormat format) noexcept
    : spi_(bus), frame_format_(format) {
  // No further initialization (use sensor defaults unless configured).
}
 
template <typename SpiType>
inline bool AS5047U<SpiType>::SetDirection(bool clockwise, uint8_t retries) {
  AS5047U_REG::SETTINGS2 s2{};
  if (!ReadReg(s2, retries)) {
    return false;
  }
  s2.bits.DIR = clockwise ? 0 : 1;
  return WriteReg(s2, retries);
}
 
// Public API: Get driver version string
inline const char* GetDriverVersion() noexcept {
  return HF_AS5047U_VERSION_STRING;
}
 
} // namespace as5047u
 
// Include template implementation
#define AS5047U_HEADER_INCLUDED
// NOLINTNEXTLINE(bugprone-suspicious-include) - Intentional: template implementation file
#include "as5047u.ipp"
#undef AS5047U_HEADER_INCLUDED