p_graphite_digester_sdk/components/tmc/ic/ztmc5130.hpp

#pragma once
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#include "../basic/tmc_ic_interface.hpp"
#include "sdk/os/zos.hpp"

extern "C" {
#include "TMC5130\TMC5130.h"
}
#ifdef HAL_SPI_MODULE_ENABLED
namespace iflytop {
#define TMC5130_LISTENER_MAX 5
/**
 * @brief
 *
 * ע�����
 *  1. �ٶȵ�λ
 *      velocity�ĵ�λ��:p/t
 *      t = 2^24/fin (finΪ����ʱ�ӣ���ʱ��Ƶ��Ϊ16MHzʱ��t = 1.048576s)
 *      ��ʱ pptԼ����pps
 *
 *      �ο�TMC5130A_datasheet_rev1.20%20(1)%20(3).pdf 38ҳ �����е���
 *
 *  2. оƬ��λ����
 *      reset(); ��λоƬ��ͬʱ�ὫоƬ�ļĴ�������ΪĬ��ֵ��һ�������²���Ҫ�û��������ø÷�������Ϊ�ڳ�ʼ��ʱ���Զ����ø÷�����
 *
 */

class Tmc5130RampStat {
 public:
  uint32_t m_state;
  // �ο�TMC5130A_datasheet_rev1.20%20(1).pdf 40ҳ
  typedef enum {
    /**
     * @brief
     *  R  ��ֻ��
     *  R+C��ֻ�������������Զ�����
     */
    ktmc5130_rs_stopl         = TMC5130_RS_STOPL,          // (R  )
    ktmc5130_rs_stopr         = TMC5130_RS_STOPR,          // (R  )
    ktmc5130_rs_latchl        = TMC5130_RS_LATCHL,         // (R+C)
    ktmc5130_rs_latchr        = TMC5130_RS_LATCHR,         // (R+C)
    ktmc5130_rs_ev_stopl      = TMC5130_RS_EV_STOPL,       // (R  )
    ktmc5130_rs_ev_stopr      = TMC5130_RS_EV_STOPR,       // (R  )
    ktmc5130_rs_ev_stop_sg    = TMC5130_RS_EV_STOP_SG,     // (R+C)
    ktmc5130_rs_ev_posreached = TMC5130_RS_EV_POSREACHED,  // (R+C)
    ktmc5130_rs_velreached    = TMC5130_RS_VELREACHED,     // (R  )
    ktmc5130_rs_posreached    = TMC5130_RS_POSREACHED,     // (R  ) �Ƿ񵽴�Ŀ��λ��
    ktmc5130_rs_vzero         = TMC5130_RS_VZERO,          // (R  )
    ktmc5130_rs_zerowait      = TMC5130_RS_ZEROWAIT,       // (R  )
    ktmc5130_rs_secondmove    = TMC5130_RS_SECONDMOVE,     // (R+C)
    ktmc5130_rs_sg            = TMC5130_RS_SG,             // (R  )
  } ramp_stat_bit_t;

  Tmc5130RampStat(uint32_t state) : m_state(state) {}
  bool isSetted(ramp_stat_bit_t bit) { return (m_state & bit) != 0; }
};

class TMC5130 : public IStepperMotor {
 public:
  typedef struct {
    SPI_HandleTypeDef *spi;
    Pin_t              csgpio          = PinNull;  //
    Pin_t              resetPin        = PinNull;  //
    Pin_t              fREEZEPin       = PinNull;  //
    Pin_t              ennPin          = PinNull;  //
    Pin_t              spi_mode_select = PinNull;  //
  } cfg_t;

 protected:
  // TMC5130Port     *m_port;
  // TMC5130Config_t *m_config;

  cfg_t m_cfg;

  ZGPIO             *m_csnpin               = NULL;
  ZGPIO             *m_ennpin               = NULL;
  ZGPIO             *m_spi_mode_select_gpio = NULL;
  SPI_HandleTypeDef *m_hspi                 = NULL;

  // uint8_t  m_channel;
  uint32_t m_lastCallPeriodicJobTick;
  int32_t  m_shadowRegister[TMC_REGISTER_COUNT];

  const uint8_t *m_registerAccessTable;
  const int32_t *m_defaultRegisterResetState;

  int32_t m_scale              = 10000;
  int32_t m_scale_deceleration = 1;

 public:
  TMC5130(/* args */);

  // static void createDeafultTMC5130Config(TMC5130Config_t *config, TMC5130Port *m_port);
  void initialize(cfg_t *cfg);

  void         enableIC(bool enable);
  virtual void enable(bool enable) { enableIC(enable); }

  uint8_t reset();

  /*******************************************************************************
   *                             ���üĴ�����д����                              *
   *******************************************************************************/

  uint32_t        readICVersion();            // 5130:0x11 5160:0x30
  virtual int32_t getXACTUAL();               // ��ȡ������ǰλ��,����������λ��ֵ��ͬ����ֵ�ǵ����ڲ������������µ�λ��
  virtual void    setXACTUAL(int32_t value);  // ���õ�����ǰλ��,����������λ��ֵ��ͬ����ֵ�ǵ����ڲ������������µ�λ��

  virtual int32_t getVACTUAL();   // ��ȡ������ǰλ��,����������λ��ֵ��ͬ����ֵ�ǵ����ڲ������������µ�λ��
  uint32_t        readXTARGET();  // ��ȡ������Ŀ��λ��

  virtual int32_t getENC_POS() { return 0; }    // TODO impl it
  virtual void    setENC_POS(int32_t value) {}  // TODO impl it

  virtual void setScale(int32_t scale);
  virtual void setScaleDenominator(int32_t scale);

  virtual void setAcceleration(float accelerationpps2);
  virtual void setDeceleration(float accelerationpps2);

  void setIHOLD_IRUN(uint8_t ihold, uint8_t irun, uint16_t iholddelay);

  void setMotorShaft(bool reverse);  // ���õ�����ת����

  uint32_t        getTMC5130_RAMPSTAT();  // �����Ĵ�����ȡ����TMC5130��״̬�Ĵ���
  Tmc5130RampStat getTMC5130_RAMPSTAT2();

  virtual void rotate(int32_t velocity);
  virtual void right(int32_t velocity);
  virtual void left(int32_t velocity);

  virtual void moveTo(int32_t position, uint32_t velocityMax);
  virtual void moveBy(int32_t relativePosition, uint32_t velocityMax);

  virtual void stop();
  virtual bool isReachTarget();  // �Ƿ񵽴�Ŀ��λ��
  virtual bool isStoped() { return isReachTarget(); }

  /*******************************************************************************
   *                             �������Ĵ�����д����                              *
   *******************************************************************************/
  // void    writeSubRegister(uint8_t address, uint32_t mask, uint32_t shift, uint32_t value);
  void    readWriteArray(uint8_t *data, size_t length);
  void    writeDatagram(uint8_t address, uint8_t x1, uint8_t x2, uint8_t x3, uint8_t x4);
  void    writeInt(uint8_t address, int32_t value);
  int32_t readInt(uint8_t address);

 private:
  uint32_t haspassedms(uint32_t now, uint32_t last);

  int32_t to_motor_acc(int32_t acc);  // rpm/s^2
  int32_t to_motor_vel(int32_t vel);  // rpm
  int32_t to_motor_pos(int32_t pos);  //

  int32_t to_user_pos(int32_t pos);  //
  int32_t to_user_vel(int32_t vel);
};
}  // namespace iflytop
#endif