as5047u_registers.hpp

Go to the documentation of this file.

 
#pragma once
#include <cstdint>
 
namespace AS5047U_REG {
//                                                                           //
//   ██╗   ██╗ ██████╗ ██╗      █████╗ ████████╗██╗██╗     ███████╗          //
//   ██║   ██║██╔═══██╗██║     ██╔══██╗╚══██╔══╝██║██║     ██╔════╝          //
//   ██║   ██║██║   ██║██║     ███████║   ██║   ██║██║     █████╗            //
//   ╚██╗ ██╔╝██║   ██║██║     ██╔══██║   ██║   ██║██║     ██╔══╝            //
//    ╚████╔╝ ╚██████╔╝███████╗██║  ██║   ██║   ██║███████╗███████╗          //
//     ╚═══╝   ╚═════╝ ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚═╝╚══════╝╚══════╝          //
//                                                                           //
//   ██████╗ ███████╗ ██████╗ ██╗███████╗████████╗███████╗██████╗ ███████╗   //
//   ██╔══██╗██╔════╝██╔════╝ ██║██╔════╝╚══██╔══╝██╔════╝██╔══██╗██╔════╝   //
//   ██████╔╝█████╗  ██║  ███╗██║███████╗   ██║   █████╗  ██████╔╝███████╗   //
//   ██╔══██╗██╔══╝  ██║   ██║██║╚════██║   ██║   ██╔══╝  ██╔══██╗╚════██║   //
//   ██║  ██║███████╗╚██████╔╝██║███████║   ██║   ███████╗██║  ██║███████║   //
//   ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═╝╚══════╝   ╚═╝   ╚══════╝╚═╝  ╚═╝╚══════╝   //
//                                                                           //
//===========================================================================//
//                          VOLATILE REGISTERS                               //
//===========================================================================//
 
struct NOP {
  static constexpr uint16_t ADDRESS = 0x0000;
  union {
    uint16_t value;
    struct {
      uint16_t reserved : 16; // No specific bits defined for NOP
    } bits;
  };
};
 
struct ERRFL {
  static constexpr uint16_t ADDRESS = 0x0001;
  union {
    uint16_t value;
    struct {
      uint16_t AGC_warning : 1;
      uint16_t MagHalf : 1;
      uint16_t P2RAM_warning : 1;
      uint16_t P2RAM_error : 1;
      uint16_t Framing_error : 1;
      uint16_t Command_error : 1;
      uint16_t CRC_error : 1;
      uint16_t WDTST : 1;
      uint16_t unused_8 : 1;
      uint16_t OffCompNotFinished : 1;
      uint16_t CORDIC_Overflow : 1;
      uint16_t reserved_11_15 : 5;
    } bits;
  };
};
 
struct PROG {
  static constexpr uint16_t ADDRESS = 0x0003;
  union {
    uint16_t value;
    struct {
      uint16_t PROGEN : 1;
      uint16_t reserved_1 : 1;
      uint16_t OTPREF : 1;
      uint16_t PROGOTP : 1;
      uint16_t reserved_4 : 1;
      uint16_t reserved_5 : 1;
      uint16_t PROGVER : 1;
      uint16_t reserved_7 : 1;
      uint16_t reserved_8_15 : 8;
    } bits;
  };
};
 
struct DIA {
  static constexpr uint16_t ADDRESS = 0x3FF5;
  union {
    uint16_t value;
    struct {
      uint16_t VDD_mode : 1;
      uint16_t LoopsFinished : 1;
      uint16_t CORDIC_overflow_flag : 1;
      uint16_t Comp_l : 1;
      uint16_t Comp_h : 1;
      uint16_t MagHalf_flag : 1;
      uint16_t CosOff_fin : 1;
      uint16_t SinOff_fin : 1;
      uint16_t OffComp_finished : 1;
      uint16_t AGC_finished : 1;
      uint16_t unused_10 : 1;
      uint16_t SPI_cnt : 2;
      uint16_t reserved_13_15 : 3;
    } bits;
  };
};
 
struct AGC {
  static constexpr uint16_t ADDRESS = 0x3FF9;
  union {
    uint16_t value;
    struct {
      uint16_t AGC_value : 8;
      uint16_t reserved_8_15 : 8;
    } bits;
  };
};
 
struct SINDATA {
  static constexpr uint16_t ADDRESS = 0x3FFA;
  union {
    uint16_t value;
    struct {
      int16_t SINDATA : 16; // Raw signed sine data
    } bits;
  };
};
 
struct COSDATA {
  static constexpr uint16_t ADDRESS = 0x3FFB;
  union {
    uint16_t value;
    struct {
      int16_t COSDATA : 16; // Raw signed cosine data
    } bits;
  };
};
 
struct VEL {
  static constexpr uint16_t ADDRESS = 0x3FFC;
  union {
    uint16_t value;
    struct {
      uint16_t VEL_value : 14;
      uint16_t reserved_14_15 : 2;
    } bits;
  };
};
 
struct MAG {
  static constexpr uint16_t ADDRESS = 0x3FFD;
  union {
    uint16_t value;
    struct {
      uint16_t MAG_value : 14;
      uint16_t reserved_14_15 : 2;
    } bits;
  };
};
 
struct ANGLEUNC {
  static constexpr uint16_t ADDRESS = 0x3FFE;
  union {
    uint16_t value;
    struct {
      uint16_t ANGLEUNC_value : 14;
      uint16_t reserved_14_15 : 2;
    } bits;
  };
};
 
struct ECC_Checksum {
  static constexpr uint16_t ADDRESS = 0x3FD0;
  union {
    uint16_t value;
    struct {
      uint16_t ECC_s : 7;         // Calculated ECC checksum
      uint16_t reserved_7_15 : 9; // Reserved bits
    } bits;
  };
};
 
struct ANGLECOM {
  static constexpr uint16_t ADDRESS = 0x3FFF;
  union {
    uint16_t value;
    struct {
      uint16_t ANGLECOM_value : 14;
      uint16_t reserved_14_15 : 2;
    } bits;
  };
};
 
//   ███╗   ██╗ ██████╗ ███╗   ██╗                                             //
//   ████╗  ██║██╔═══██╗████╗  ██║                                             //
//   ██╔██╗ ██║██║   ██║██╔██╗ ██║                                             //
//   ██║╚██╗██║██║   ██║██║╚██╗██║                                             //
//   ██║ ╚████║╚██████╔╝██║ ╚████║                                             //
//   ╚═╝  ╚═══╝ ╚═════╝ ╚═╝  ╚═══╝                                             //
//                                                                             //
//   ██╗   ██╗ ██████╗ ██╗      █████╗ ████████╗██╗██╗     ███████╗            //
//   ██║   ██║██╔═══██╗██║     ██╔══██╗╚══██╔══╝██║██║     ██╔════╝            //
//   ██║   ██║██║   ██║██║     ███████║   ██║   ██║██║     █████╗              //
//   ╚██╗ ██╔╝██║   ██║██║     ██╔══██║   ██║   ██║██║     ██╔══╝              //
//    ╚████╔╝ ╚██████╔╝███████╗██║  ██║   ██║   ██║███████╗███████╗            //
//     ╚═══╝   ╚═════╝ ╚══════╝╚═╝  ╚═╝   ╚═╝   ╚═╝╚══════╝╚══════╝            //
//                                                                             //
//   ██████╗ ███████╗ ██████╗ ██╗███████╗████████╗███████╗██████╗ ███████╗     //
//   ██╔══██╗██╔════╝██╔════╝ ██║██╔════╝╚══██╔══╝██╔════╝██╔══██╗██╔════╝     //
//   ██████╔╝█████╗  ██║  ███╗██║███████╗   ██║   █████╗  ██████╔╝███████╗     //
//   ██╔══██╗██╔══╝  ██║   ██║██║╚════██║   ██║   ██╔══╝  ██╔══██╗╚════██║     //
//   ██║  ██║███████╗╚██████╔╝██║███████║   ██║   ███████╗██║  ██║███████║     //
//   ╚═╝  ╚═╝╚══════╝ ╚═════╝ ╚═╝╚══════╝   ╚═╝   ╚══════╝╚═╝  ╚═╝╚══════╝     //
//                                                                             //
//   ██╗ ██████╗ ████████╗██████╗ ██╗                                          //
//   ██║██╔═══██╗╚══██╔══╝██╔══██╗██║                                          //
//   ██║██║   ██║   ██║   ██████╔╝██║                                          //
//   ╚═╝██║   ██║   ██║   ██╔═══╝ ╚═╝                                          //
//   ██╗╚██████╔╝   ██║   ██║     ██╗                                          //
//   ╚═╝ ╚═════╝    ╚═╝   ╚═╝     ╚═╝                                          //
//=============================================================================//
//                      NON-VOLATILE REGISTERS (OTP)                           //
//=============================================================================//
// Addresses 0x0015–0x001B (DISABLE, ZPOSM, ZPOSL, SETTINGS1/2/3, ECC) support
// soft write: SPI read/write works multiple times; content is in volatile shadow
// and is lost after hardware reset. OTP programming (PROG register) burns the
// current shadow content permanently; after that, values survive reset and
// cannot be overwritten. Default state is 0x0000 if never programmed.
 
struct DISABLE {
  static constexpr uint16_t ADDRESS = 0x0015;
  union {
    uint16_t value;
    struct {
      uint16_t UVW_off : 1;
      uint16_t ABI_off : 1;
      uint16_t reserved_2_5 : 4;
      uint16_t FILTER_disable : 1;
      uint16_t reserved_7 : 1;
      uint16_t reserved_8_15 : 8;
    } bits;
  };
 
  enum class UVWMode : uint8_t {
    Normal = 0,  
    Tristate = 1 
  };
 
  enum class ABIMode : uint8_t {
    Normal = 0,  
    Tristate = 1 
  };
 
  enum class FilterMode : uint8_t {
    Enabled = 0, 
    Disabled = 1 
  };
};
 
struct ZPOSM {
  static constexpr uint16_t ADDRESS = 0x0016;
  union {
    uint16_t value;
    struct {
      uint16_t ZPOSM_bits : 8;
      uint16_t reserved_8_15 : 8;
    } bits;
  };
};
 
struct ZPOSL {
  static constexpr uint16_t ADDRESS = 0x0017;
  union {
    uint16_t value;
    struct {
      uint16_t ZPOSL_bits : 6;
      uint16_t Dia1_en : 1;
      uint16_t Dia2_en : 1;
      uint16_t reserved_8_15 : 8;
    } bits;
  };
};
 
struct SETTINGS1 {
  static constexpr uint16_t ADDRESS = 0x0018;
  union {
    uint16_t value;
    struct {
      uint16_t K_max : 3;
      uint16_t K_min : 3;
      uint16_t Dia3_en : 1;
      uint16_t Dia4_en : 1;
      uint16_t reserved_8_15 : 8;
    } bits;
  };
  enum class AdaptiveFilterKmax : uint8_t {
    Code0 = 0b000, 
    Code1 = 0b001, 
    Code2 = 0b010, 
    Code3 = 0b011, 
    Code4 = 0b100, 
    Code5 = 0b101, 
    Code6 = 0b110, 
    Code7 = 0b111  
  };
  enum class AdaptiveFilterKmin : uint8_t {
    Code0 = 0b000, 
    Code1 = 0b001, 
    Code2 = 0b010, 
    Code3 = 0b011, 
    Code4 = 0b100, 
    Code5 = 0b101, 
    Code6 = 0b110, 
    Code7 = 0b111  
  };
};
 
struct SETTINGS2 {
  static constexpr uint16_t ADDRESS = 0x0019;
  union {
    uint16_t value;
    struct {
      uint16_t IWIDTH : 1;
      uint16_t NOISESET : 1;
      uint16_t DIR : 1;
      uint16_t UVW_ABI : 1;
      uint16_t DAECDIS : 1;
      uint16_t ABI_DEC : 1;
      uint16_t Data_select : 1;
      uint16_t PWMon : 1;
      uint16_t reserved_8_15 : 8;
    } bits;
  };
  enum class IndexWidth : uint8_t {
    Width3LSB = 0, 
    Width1LSB = 1  
  };
  enum class NoiseSetting : uint8_t {
    Normal = 0,  
    HighTemp = 1 
  };
  enum class RotationDirection : uint8_t {
    Normal = 0,  
    Inverted = 1 
  };
  enum class OutputInterfaceMode : uint8_t {
    ABI_PWM_on_W = 0, 
    UVW_PWM_on_I = 1  
  };
  enum class DynamicCompensation : uint8_t {
    Enabled = 0, 
    Disabled = 1 
  };
  enum class ABICountMode : uint8_t {
    Binary = 0, 
    Decimal = 1 
  };
  enum class AngleOutputSource : uint8_t {
    UseANGLECOM = 0, 
    UseANGLEUNC = 1  
  };
  enum class PWMMode : uint8_t {
    Disabled = 0, 
    Enabled = 1   
  };
};
 
static_assert(sizeof(SETTINGS2) == 2, "SETTINGS2 must be 2 bytes");
 
struct SETTINGS3 {
  static constexpr uint16_t ADDRESS = 0x001A;
  union {
    uint16_t value;
    struct {
      uint16_t UVWPP : 3;
      uint16_t HYS : 2;
      uint16_t ABIRES : 3;
      uint16_t reserved_8_15 : 8;
    } bits;
  };
  enum class UVWPolePairs : uint8_t {
    PP1 = 0b000,    
    PP2 = 0b001,    
    PP3 = 0b010,    
    PP4 = 0b011,    
    PP5 = 0b100,    
    PP6 = 0b101,    
    PP7 = 0b110,    
    PP7_ALT = 0b111 
  };
  enum class Hysteresis : uint8_t {
    LSB_1 = 0b00, 
    LSB_2 = 0b01, 
    LSB_3 = 0b10, 
    NONE = 0b11   
  };
  enum class ABIResolution : uint8_t {
    Code0 = 0b000, 
    Code1 = 0b001, 
    Code2 = 0b010, 
    Code3 = 0b011, 
    Code4 = 0b100, 
    Code5 = 0b101, 
    Code6 = 0b110, 
    Code7 = 0b111  
  };
};
 
static_assert(sizeof(SETTINGS3) == 2, "SETTINGS3 must be 2 bytes");
 
struct ECC {
  static constexpr uint16_t ADDRESS = 0x001B;
  union {
    uint16_t value;
    struct {
      uint16_t ECC_chsum : 7;
      uint16_t ECC_en : 1;
      uint16_t reserved_8_15 : 8;
    } bits;
  };
 
  enum class ECCMode : uint8_t {
    Disabled = 0, 
    Enabled = 1   
  };
};
 
} // namespace AS5047U_REG