circulo_encoder_configuration.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <cstdint>
 
#include "util.h"
 
class Cia402Drive;
class MotionMasterError;
 
class CirculoEncoderConfiguration {
 public:
  CirculoEncoderConfiguration(
      Cia402Drive& cia402_drive, uint8_t encoder_ordinal,
      uint8_t battery_mode_max_acceleration, uint32_t external_circulo_type,
      const std::function<void()>& started_callback = {},
      const std::function<void(uint8_t)>& progress_callback = {});
 
  MotionMasterError start();
 
 private:
  Cia402Drive& cia402_drive_;
  uint8_t encoder_ordinal_;
  uint8_t battery_mode_max_acceleration_;
  uint32_t external_circulo_type_;
  EncoderLocation encoder_location_ = EncoderLocation::kUnspecified;
  CirculoType circulo_type_ = CirculoType::kUnspecified;
  uint8_t singleturn_bits_ = 0;
 
  const std::function<void()>& started_callback_;
  const std::function<void(uint8_t)>& progress_callback_;
 
  double progress_ = 0;
 
  // Prevent multiple encoder configurations from running on the same device
  // at the same time
  static inline std::unordered_map<int32_t, std::mutex> mutex_map_;
 
  // Registers that have CALIBRATION written are not used by
  // configuration. They will be written when calibrating the encoder.
 
  // Singleturn
  // Tuple: {Circulo type that uses the register value, address, value}
  static inline const std::list<std::tuple<CirculoType, uint8_t, uint8_t>>
      singleturn_address_value_list_ = {
          // Register 0x00 = 0x00 (default=0x00)
          {CirculoType::kUnspecified, 0x00, 0x00},
 
          // Register 0x01 = CALIBRATION (default = 0x00)
          // Register 0x02 = CALIBRATION (default = 0x00)
          // Register 0x03 = CALIBRATION (default = 0x00)
          // Register 0x04 = CALIBRATION (default = 0x00)
          // Register 0x05 = 0x88 (default = 0x88)
          {CirculoType::kUnspecified, 0x05, 0x88},
 
          // Register 0x06 = 0x00 (default = 0x00)
          {CirculoType::kUnspecified, 0x06, 0x00},
 
          // Register 0x07 = CALIBRATION (default = 0x00)
          // Register 0x08 = CALIBRATION (default = 0x00)
          // Register 0x09 = CALIBRATION (default = 0x00)
          // Register 0x0A = CALIBRATION (default = 0x00)
          // Register 0x0B = 0x02 (default = 0x02)
          {CirculoType::kCirculo7, 0x0B, 0x02},
          {CirculoType::kCirculo7Smm, 0x0B, 0x52},
          {CirculoType::kCirculo9, 0x0B, 0x02},
          {CirculoType::kCirculo9Smm, 0x0B, 0x52},
          {CirculoType::kCirculo18Bit, 0x0B, 0x52},
 
          // Register 0x0C = 0x6C (Mask AN_MAX error; default = 0x00)
          {CirculoType::kUnspecified, 0x0C, 0x6C},
 
          // Register 0x0D = 0xC0 (default = 0x00)
          {CirculoType::kUnspecified, 0x0D, 0xC0},
 
          // Register 0x0E = 0x04 (default=0x06)
          {CirculoType::kUnspecified, 0x0E, 0x04},
 
          // Register 0x0F = MPC, the master period count: 0x04 for 16 pole
          // pairs, 0x05 for 32, 0x06 for 64 (default=0x05)
          {CirculoType::kCirculo7, 0x0F, 0x05},
          {CirculoType::kCirculo7Smm, 0x0F, 0x05},
          {CirculoType::kCirculo9, 0x0F, 0x06},
          {CirculoType::kCirculo9Smm, 0x0F, 0x06},
          {CirculoType::kCirculo18Bit, 0x0F, 0x04},
 
          // Register 0x10 = 0x00 (default=0x00)
          {CirculoType::kUnspecified, 0x10, 0x00},
 
          // Register 0x11 = OUT_MSB, which puts the MSB of the output word at
          // bit 13 plus the value. So 0x04 for 18 singleturn bits, 0x05 for 19,
          // 0x06 for 20. (default=0xA5)
          {CirculoType::kCirculo7, 0x11, 0x05},
          {CirculoType::kCirculo7Smm, 0x11, 0x05},
          {CirculoType::kCirculo9, 0x11, 0x06},
          {CirculoType::kCirculo9Smm, 0x11, 0x06},
          {CirculoType::kCirculo18Bit, 0x11, 0x04},
 
          // Register 0x12 = 0x00 (default=0x00)
          {CirculoType::kUnspecified, 0x12, 0x00},
 
          // Register 0x13/0x14 = 0xFF/0x0F (default=0xFF/0x0F)
          {CirculoType::kUnspecified, 0x13, 0xFF},
          {CirculoType::kUnspecified, 0x14, 0x0F},
 
          // Register 0x15 = 0x13 (default=0x13)
          {CirculoType::kUnspecified, 0x15, 0x13},
 
          // Register 0x16 = 0x10 (default=0x10)
          {CirculoType::kUnspecified, 0x16, 0x10},
 
          // Register 0x17 = 0x02 (default=0x02)
          {CirculoType::kUnspecified, 0x17, 0x02},
 
          // Register 0x18 = 0x00 (default=0x00)
          {CirculoType::kUnspecified, 0x18, 0x00},
 
          // Write the iC-MU configuration to EEPROM
          {CirculoType::kUnspecified, 0x75, 0x01}};
 
  // Multiturn - Stage 1
  // Tuple: {Circulo type that uses the register value, address, value}
  static inline const std::list<std::tuple<CirculoType, uint8_t, uint8_t>>
      multiturn_address_value_stage_1_list_ = {
 
          // Register 0x00 = 0x00 (default=0x00)
          {CirculoType::kUnspecified, 0x00, 0x00},
 
          // Register 0x01 = CALIBRATION (default=0x00)
          // Register 0x02 = CALIBRATION (default=0x00)
          // Register 0x03 = CALIBRATION (default=0x00)
          // Register 0x04 = CALIBRATION (default=0x00)
          // Register 0x05 = 0x88 (default=0x88)
          {CirculoType::kUnspecified, 0x05, 0x88},
 
          // Register 0x06 = 0x00 (default=0x00)
          {CirculoType::kUnspecified, 0x06, 0x00},
 
          // Register 0x07 = CALIBRATION (default=0x00)
          // Register 0x08 = CALIBRATION (default=0x00)
          // Register 0x09 = CALIBRATION (default=0x00)
          // Register 0x0A = CALIBRATION (default=0x00)
          // Register 0x0B = 0x02 (default=0x02)
          {CirculoType::kCirculo7, 0x0B, 0x02},
          {CirculoType::kCirculo7Smm, 0x0B, 0x52},
          {CirculoType::kCirculo9, 0x0B, 0x02},
          {CirculoType::kCirculo9Smm, 0x0B, 0x52},
          {CirculoType::kCirculo18Bit, 0x0B, 0x52},
 
          // Register 0x0C = 0x6C (Mask AN_MAX error; default=0x00)
          {CirculoType::kUnspecified, 0x0C, 0x6C},
 
          // Register 0x0D = 0xC0 (default=0x00)
          {CirculoType::kUnspecified, 0x0D, 0xC0},
 
          // Register 0x0E = 0x44 (default=0x06)
          {CirculoType::kUnspecified, 0x0E, 0x44},
 
          // Register 0x0F = MPC, the master period count: 0x04 for 16 pole
          // pairs, 0x05 for 32, 0x06 for 64 (default=0x05)
          {CirculoType::kCirculo7, 0x0F, 0x05},
          {CirculoType::kCirculo7Smm, 0x0F, 0x05},
          {CirculoType::kCirculo9, 0x0F, 0x06},
          {CirculoType::kCirculo9Smm, 0x0F, 0x06},
          {CirculoType::kCirculo18Bit, 0x0F, 0x04},
 
          // Register 0x10 = 0x6F (default=0x00)
          {CirculoType::kUnspecified, 0x10, 0x6F},
 
          // Register 0x11 = OUT_MSB over the singleturn bits plus the 18
          // multiturn bits, so bit 13 + the value is the top bit of the whole
          // word. 18 + 18 bits is 0x16, 19 + 18 is 0x17, 20 + 18 is 0x18.
          // (default=0xA5)
          {CirculoType::kCirculo7, 0x11, 0x17},
          {CirculoType::kCirculo7Smm, 0x11, 0x17},
          {CirculoType::kCirculo9, 0x11, 0x18},
          {CirculoType::kCirculo9Smm, 0x11, 0x18},
          {CirculoType::kCirculo18Bit, 0x11, 0x16},
 
          // Register 0x12 = 0x00 (default=0x00)
          {CirculoType::kUnspecified, 0x12, 0x00},
 
          // Register 0x13/0x14 = 0xFF/0x0F (default=0xFF/0x0F)
          {CirculoType::kUnspecified, 0x13, 0xFF},
          {CirculoType::kUnspecified, 0x14, 0x0F},
 
          // Register 0x15 = 0x13 (default=0x13)
          {CirculoType::kUnspecified, 0x15, 0x13},
 
          // Register 0x16 = 0x10 (default=0x10)
          {CirculoType::kUnspecified, 0x16, 0x10},
 
          // Register 0x17 = 0x02 (default=0x02)
          {CirculoType::kUnspecified, 0x17, 0x02},
 
          // Register 0x18 = 0x00 (default=0x00)
          {CirculoType::kUnspecified, 0x18, 0x00},

 
          // Configure I2C_DEVID (0x5E) to WRITE_EEPROM (0xA0). This tells the
          // iC-MU that we want to use the I2C communication to write to the
          // EEPROM.
          {CirculoType::kUnspecified, 0x5E, 0xA0},
 
          // Set the I2C_RAM_START (0x5C) to USER_EXCHANGE_REGISTERS_1 (0x60).
          // This tells the iC-MU that the first value that he should write to
          // the EEPROM is in the iC-MU RAM address 0x60. These
          // USER_EXCHANGE_REGISTERS are used exclusively to store values that
          // should be written to an external device via I2C (like the EEPROM
          // or the iC-PVL).
          {CirculoType::kUnspecified, 0x5C, 0x60},
 
          // Set I2C_DEV_START (0x5B) to 0x40. This sets the first EEPROM
          // address that should be written. Basically this means that the
          // value written in the iC-MU RAM address 0x60 will be written to
          // the EEPROM address 0x40. The reason why we start at EEPROM
          // address 0x40 is that the EEPROM range 0x00-0x3F is used for the
          // iC-MU configuration, and the iC-PVL configuration is stored in
          // the range 0x40-0x4C, storing the value of the iC-PVL register
          // 0x00 in EEPROM address 0x40, iC-PVL register 0x01 in EEPROM
          // address 0x41, and so on.
          {CirculoType::kUnspecified, 0x5B, 0x40},
 
          // Set I2C_RAM_END (0x5D) to 0x6C. This tells the iC-MU when to stop
          // writing the values in the USER_EXCHANGE_REGISTERS to the EEPROM.
          // Since we want to write 13 values (EEPROM address 0x40 to address
          // 0x4C), we need to use USER_EXCHANGE_REGISTERS_1 (0x60) to
          // USER_EXCHANGE_REGISTERS_13 (0x6C).
          {CirculoType::kUnspecified, 0x5D, 0x6C}};
 
  // Multiturn - Stage 2 - CRC
  // Tuple: {Circulo type that uses the register value, encoder position,
  // address, value}
  static inline const std::list<
      std::tuple<CirculoType, EncoderLocation, uint8_t, uint8_t>>
      multiturn_address_value_stage_2_list_ = {
          // iC-PVL register 0x00 = 0x28 (default=0x00)
          {CirculoType::kUnspecified, EncoderLocation::kUnspecified, 0x60,
           0x28},
 
          // iC-PVL register 0x01 = 0x09 (default=0x00)
          {CirculoType::kUnspecified, EncoderLocation::kUnspecified, 0x61,
           0x09},
 
          // iC-PVL register 0x02 = PCR, the period counts per revolution less
          // one: 0x0F for 16 pole pairs, 0x1F for 32, 0x3F for 64
          // (default=0x00)
          {CirculoType::kCirculo7, EncoderLocation::kUnspecified, 0x62, 0x1F},
          {CirculoType::kCirculo7Smm, EncoderLocation::kUnspecified, 0x62,
           0x1F},
          {CirculoType::kCirculo9, EncoderLocation::kUnspecified, 0x62, 0x3F},
          {CirculoType::kCirculo9Smm, EncoderLocation::kUnspecified, 0x62,
           0x3F},
          {CirculoType::kCirculo18Bit, EncoderLocation::kUnspecified, 0x62,
           0x0F},
 
          // iC-PVL register 0x03 = {Motor shaft: 0x5D, Driving shaft: 0x68}
          // (default=0x00)
          {CirculoType::kUnspecified, EncoderLocation::kMotorShaft, 0x63, 0x5D},
          {CirculoType::kUnspecified, EncoderLocation::kDrivingShaft, 0x63,
           0x68},
 
          // iC-PVL register 0x04 = 0x50 (default=0x00)
          {CirculoType::kUnspecified, EncoderLocation::kUnspecified, 0x64,
           0x50},
 
          // iC-PVL register 0x05 = 0x30 (default=0x00)
          {CirculoType::kUnspecified, EncoderLocation::kUnspecified, 0x65, 0x30}
 
          // iC-PVL register 0x06 - calculated CRC value of the previous
          // registers: 0x00-0x05 (default=0x00)
  };
 
  // Multiturn - Stage 3
  // Tuple: {address, value}
  static inline const std::list<std::tuple<uint8_t, uint8_t>>
      multiturn_address_value_stage_3_list_ = {
          // iC-PVL registers 0x07-0x0B = 0x0000000000 (default=0x00)
          {0x67, 0x00}, {0x68, 0x00}, {0x69, 0x00}, {0x6A, 0x00}, {0x6B, 0x00},
 
          // iC-PVL register 0x0C - calculated CRC value of the previous
          // registers: 0x07-0x0B (default=0x00)
  };
 
  // Multiturn - Stage 4 - Write REBOOT to iC-PVL. This will force iC-PVL to
  // re-read the EEPROM and load those values in the RAM.
  static inline const std::list<std::tuple<uint8_t, uint8_t>>
      multiturn_address_value_stage_4_list_ = {
          // Configure I2C_DEVID (0x5E) to WRITE_ICPVL (0xC2). This tells the
          // iC-MU that we want to use the I2C communication to write to the
          // iC-PVL.
          {0x5E, 0xC2},
 
          // Set the I2C_RAM_START (0x5C) to USER_EXCHANGE_REGISTERS_1 (0x60).
          // This tells the iC-MU that the first value that he should write to
          // the iC-PVL is in the iC-MU RAM address 0x60. These
          // USER_EXCHANGE_REGISTERS are used exclusively to store values that
          // should be written to an external device via I2C (like the EEPROM
          // or the iC-PVL).
          {0x5C, 0x60},
 
          // Set I2C_DEV_START (0x5B) to 0x11. This sets the first iC-PVL
          // register that should be written. Basically this means that the
          // value written in the iC-MU RAM address 0x60 will be written to
          // the iC-PVL register 0x11.
          {0x5B, 0x11},
 
          // Set I2C_RAM_END (0x5D) to 0x60. This tells the iC-MU when to stop
          // writing the values in the USER_EXCHANGE_REGISTERS to the iC-PVL.
          // Since we want to only write one value (iC-PVL address 0x11), we
          // need to use only USER_EXCHANGE_REGISTERS_1 (0x60), so both
          // I2C_RAM_END and I2C_RAM_START are set to that value.
          {0x5D, 0x60},
 
          // Now we can write each of the values we want to write to the
          // iC-PVL in the USER_EXCHANGE_REGISTERS. iC-PVL register 0x11 =
          // 0x03 (default=0x00). This will write REBOOT to the iC-PVL CMD
          // register.
          {0x60, 0x03},
 
          // Set CMD_MU (0x75) to I2C_COM (0x0A). This will start the I2C
          // communication with all the parameters that were configured above,
          // effectively writing the REBOOT command to the iC-PVL.
          {0x75, 0x0A}};
 
  // Multiturn - Stage 5 - Reset iC-PVL errors (SCLR) and re-calculate
  // absolute position (ABS_RESET)
  static inline const std::list<std::tuple<uint8_t, uint8_t>>
      multiturn_address_value_stage_5_list_ = {
          // Configure I2C_DEVID (0x5E) to WRITE_ICPVL (0xC2). This tells the
          // iC-MU that we want to use the I2C communication to write to the
          // iC-PVL.
          {0x5E, 0xC2},
 
          // Set the I2C_RAM_START (0x5C) to USER_EXCHANGE_REGISTERS_1 (0x60).
          // This tells the iC-MU that the first value that he should write to
          // the iC-PVL is in the iC-MU RAM address 0x60. These
          // USER_EXCHANGE_REGISTERS are used exclusively to store values that
          // should be written to an external device via I2C (like the EEPROM
          // or the iC-PVL).
          {0x5C, 0x60},
 
          // Set I2C_DEV_START (0x5B) to 0x11. This sets the first iC-PVL
          // register that should be written. Basically this means that the
          // value written in the iC-MU RAM address 0x60 will be written to
          // the iC-PVL register 0x11.
          {0x5B, 0x11},
 
          // Set I2C_RAM_END (0x5D) to 0x60. This tells the iC-MU when to stop
          // writing the values in the USER_EXCHANGE_REGISTERS to the iC-PVL.
          // Since we want to only write one value (iC-PVL address 0x11), we
          // need to use only USER_EXCHANGE_REGISTERS_1 (0x60), so both
          // I2C_RAM_END and I2C_RAM_START are set to that value.
          {0x5D, 0x60},
 
          // Now we can write each of the values we want to write to the
          // iC-PVL in the USER_EXCHANGE_REGISTERS.
 
          // iC-PVL register 0x11 = 0x05 (default=0x00). This will write SCLR
          // to the iC-PVL CMD register.
          {0x60, 0x05},
 
          // Set CMD_MU (0x75) to I2C_COM (0x0A). This will start the I2C
          // communication with all the parameters
          // that were configured above, effectively writing the SCLR command
          // to the iC-PVL.
          {0x75, 0x0A},
 
          // Send ABS_RESET command to iC-MU
          {0x75, 0x03}};
 
  // Stage 6
  static inline const std::list<std::tuple<uint8_t, uint8_t>>
      multiturn_address_value_stage_6_list_ = {
          // Change value of I2C_POS to 1 to be able to read the sync bits
          // iC-PVL register 0x05 = 0xB0 (value before = 0x30)
          // Configure I2C_DEVID (0x5E) to WRITE_ICPVL (0xC2). This tells the
          // iC-MU that we want to use the I2C communication to write to the
          // iC-PVL.
          {0x5E, 0xC2},
 
          // Set the I2C_RAM_START (0x5C) to USER_EXCHANGE_REGISTERS_1 (0x60).
          // This tells the iC-MU that the first value that he should write to
          // the iC-PVL is in the iC-MU RAM address 0x60. These
          // USER_EXCHANGE_REGISTERS are used exclusively to store values that
          // should be written to an external device via I2C (like the EEPROM
          // or the iC-PVL).
          {0x5C, 0x60},
 
          // Set I2C_DEV_START (0x5B) to 0x05. This sets the first iC-PVL
          // register that should be written. Basically this means that the
          // value written in the iC-MU RAM address 0x60 will be written to
          // the iC-PVL register 0x05.
          {0x5B, 0x05},
 
          // Set I2C_RAM_END (0x5D) to 0x60. This tells the iC-MU when to stop
          // writing the values in the USER_EXCHANGE_REGISTERS to the iC-PVL.
          // Since we want to only write one value (iC-PVL address 0x05), we
          // need to use only USER_EXCHANGE_REGISTERS_1 (0x60), so both
          // I2C_RAM_END and I2C_RAM_START are set to that value.
          {0x5D, 0x60},
 
          // Now we can write each of the values we want to write to the
          // iC-PVL in the USER_EXCHANGE_REGISTERS.
 
          // iC-PVL register 0x05 = 0xB0 (default=0x00). This will write 0xB0
          // to the iC-PVL 0x05 register.
          {0x60, 0xB0},
 
          // Set CMD_MU (0x75) to I2C_COM (0x0A). This will start the I2C
          // communication with all the parameters that were configured above,
          // effectively writing the SCLR command to the iC-PVL.
          {0x75, 0x0A},
 
          // Read iC-PVL sync bits (iC-PVL address 0x0D, bit 2:0)
 
          // Configure I2C_DEVID (0x5E) to READ_ICPVL (0xC3). This tells the
          // iC-MU that we want to use the I2C communication to read the
          // iC-PVL.
          {0x5E, 0xC3},
 
          // Set the I2C_RAM_START (0x5C) to USER_EXCHANGE_REGISTERS_1 (0x60).
          // This tells the iC-MU that the first value that he should write to
          // the iC-PVL is in the iC-MU RAM address 0x60. These
          // USER_EXCHANGE_REGISTERS are used exclusively to store values that
          // should be written to an external device via I2C (like the EEPROM
          // or the iC-PVL).
          {0x5C, 0x60},
 
          // Set I2C_DEV_START (0x5B) to 0x0D. This sets the first iC-PVL
          // register that should be read. Basically this means that the value
          // read in the iC-PVL register 0x0D will be written in the iC-MU RAM
          // address 0x60.
          {0x5B, 0x0D},
 
          // Set I2C_RAM_END (0x5D) to 0x60. This tells the iC-MU when to stop
          // reading the values and writing them to the
          // USER_EXCHANGE_REGISTERS to the iC-PVL. Since we want to only read
          // one value (iC-PVL address 0x0D), we need to use only
          // USER_EXCHANGE_REGISTERS_1 (0x60), so both I2C_RAM_END and
          // I2C_RAM_START are set to that value.
          {0x5D, 0x60},
 
          // Set CMD_MU (0x75) to I2C_COM (0x0A). This will start the I2C
          // communication with all the parameters that were configured above,
          // effectively reading the iC-PVL register 0x0D to the iC-MU
          // register 0x60.
          {0x75, 0x0A}};
 
  // Stage 7
  static inline const std::list<std::tuple<uint8_t, uint8_t>>
      multiturn_address_value_stage_7_list_ = {
          // Change value of I2C_POS back to 0
 
          // iC-PVL register 0x05 = 0x30
          // Configure I2C_DEVID (0x5E) to WRITE_ICPVL (0xC2). This tells the
          // iC-MU that we want to use the I2C communication to write to the
          // iC-PVL.
          {0x5E, 0xC2},
 
          // Set the I2C_RAM_START (0x5C) to USER_EXCHANGE_REGISTERS_1 (0x60).
          // This tells the iC-MU that the first value that he should write to
          // the iC-PVL is in the iC-MU RAM address 0x60. These
          // USER_EXCHANGE_REGISTERS are used exclusively to store values that
          // should be written to an external device via I2C (like the EEPROM
          // or the iC-PVL).
          {0x5C, 0x60},
 
          // Set I2C_DEV_START (0x5B) to 0x05. This sets the first iC-PVL
          // register that should be written. Basically this means that the
          // value written in the iC-MU RAM address 0x60 will be written to
          // the iC-PVL register 0x05.
          {0x5B, 0x05},
 
          // Set I2C_RAM_END (0x5D) to 0x60. This tells the iC-MU when to stop
          // writing the values in the USER_EXCHANGE_REGISTERS to the iC-PVL.
          // Since we want to only write one value (iC-PVL address 0x05), we
          // need to use only USER_EXCHANGE_REGISTERS_1 (0x60), so both
          // I2C_RAM_END and I2C_RAM_START are set to that value.
          {0x5D, 0x60},
 
          // Now we can write each of the values we want to write to the
          // iC-PVL in the USER_EXCHANGE_REGISTERS.
 
          // iC-PVL register 0x05 = 0x30 (default=0x00). This will write 0x30
          // to the iC-PVL 0x05 register.
          {0x60, 0x30},
 
          // Set CMD_MU (0x75) to I2C_COM (0x0A). This will start the I2C
          // communication with all the parameters that were configured above,
          // effectively writing the SCLR command to the iC-PVL.
          {0x75, 0x0A}};
 
  MotionMasterError configure_singleturn();
 
  MotionMasterError configure_multiturn();
 
  void add_action_to_progress(uint32_t total_actions,
                              uint32_t actions_to_add = 1);
 
  void sleep_with_progress(uint32_t milliseconds, uint32_t total_actions);
 
  MotionMasterError ignore_biss_status_bits(bool ignore);
 
  MotionMasterError write_register(uint8_t address, uint8_t value);
 
  static uint8_t crc(const std::vector<uint8_t>& data);
};