as5047u.hpp

Go to the documentation of this file.

 
#pragma once
#include "as5047u_spi_interface.hpp"
#include "as5047u_registers.hpp"
#include "as5047u_version.h"
#include <algorithm>
#include <array>
#include <atomic>
#include <bitset>
#include <cmath> // for M_PI and math functions
#include <cstdint>
#include <cstdio>     // for printf
#include <functional> // for std::function
#include <utility>    // for std::pair
 
// Error flags from ERRFL register
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 
};
 
// -----------------------------------------------------------------------------
// 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 {
 
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 * static_cast<float>(M_PI)) / 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 * static_cast<float>(M_PI))) & 0x3FFF;
    }
  };
 
  struct Velocity {
    static constexpr float DEG_PER_LSB = 24.141F;
    static constexpr float RAD_PER_LSB = DEG_PER_LSB * M_PI / 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();
 
  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>
  bool WriteReg(const RegT& reg, uint8_t retries = AS5047U_CFG::CRC_RETRIES) {
    return writeRegister(RegT::ADDRESS, encode(reg), retries);
  }
 
  AS5047U_Error GetStickyErrorFlags() const;
 
  // ===========================================================================
  // 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
  uint16_t rawReadRegister(uint16_t addr) const; 
  uint16_t readRegister(uint16_t addr) const;    
  bool writeRegister(uint16_t addr, uint16_t val, uint8_t retries) const;
 
  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) {
  auto s2 = ReadReg<AS5047U_REG::SETTINGS2>();
  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 "../src/as5047u.ipp"
#undef AS5047U_HEADER_INCLUDED