HighPowerStepperDriver.h

Go to the documentation of this file.

// Copyright Pololu Corporation.  For more information, see http://www.pololu.com/

 
#pragma once
 
#include <Arduino.h>
#include <SPI.h>
 

enum class HPSDRegAddr : uint8_t
{
  CTRL   = 0x00,
  TORQUE = 0x01,
  OFF    = 0x02,
  BLANK  = 0x03,
  DECAY  = 0x04,
  STALL  = 0x05,
  DRIVE  = 0x06,
  STATUS = 0x07,
};
 

class DRV8711SPI
{
public:
  void setChipSelectPin(uint8_t pin)
  {
    csPin = pin;
    digitalWrite(csPin, LOW);
    pinMode(csPin, OUTPUT);
  }

  uint16_t readReg(uint8_t address)
  {
    // Read/write bit and register address are the first 4 bits of the first
    // byte; data is in the remaining 4 bits of the first byte combined with
    // the second byte (12 bits total).
 
    selectChip();
    uint16_t dataOut = transfer((0x8 | (address & 0b111)) << 12);
    deselectChip();
    return dataOut & 0xFFF;
  }

  uint16_t readReg(HPSDRegAddr address)
  {
    return readReg((uint8_t)address);
  }

  void writeReg(uint8_t address, uint16_t value)
  {
    // Read/write bit and register address are the first 4 bits of the first
    // byte; data is in the remaining 4 bits of the first byte combined with
    // the second byte (12 bits total).
 
    selectChip();
    transfer(((address & 0b111) << 12) | (value & 0xFFF));
 
    // The CS line must go low after writing for the value to actually take
    // effect.
    deselectChip();
  }

  void writeReg(HPSDRegAddr address, uint16_t value)
  {
    writeReg((uint8_t)address, value);
  }
 
private:
 
  SPISettings settings = SPISettings(500000, MSBFIRST, SPI_MODE0);
 
  uint16_t transfer(uint16_t value)
  {
    return SPI.transfer16(value);
  }
 
  void selectChip()
  {
    digitalWrite(csPin, HIGH);
    SPI.beginTransaction(settings);
  }
 
  void deselectChip()
  {
   SPI.endTransaction();
   digitalWrite(csPin, LOW);
  }
 
  uint8_t csPin;
};
 

enum class HPSDStepMode : uint16_t
{
  MicroStep256 = 256,
  MicroStep128 = 128,
  MicroStep64  =  64,
  MicroStep32  =  32,
  MicroStep16  =  16,
  MicroStep8   =   8,
  MicroStep4   =   4,
  MicroStep2   =   2,
  MicroStep1   =   1,
};

enum class HPSDDecayMode : uint8_t
{
  Slow                = 0b000,
  SlowIncMixedDec     = 0b001,
  Fast                = 0b010,
  Mixed               = 0b011,
  SlowIncAutoMixedDec = 0b100,
  AutoMixed           = 0b101,
};

enum class HPSDStatusBit : uint8_t
{
  OTS = 0,

  AOCP = 1,

  BOCP = 2,

  APDF = 3,

  BPDF = 4,

  UVLO = 5,

  STD = 6,

  STDLAT = 7,
};
 

class HighPowerStepperDriver
{
public:
  HighPowerStepperDriver()
  {
    // All settings set to power-on defaults
    ctrl   = 0xC10;
    torque = 0x1FF;
    off    = 0x030;
    blank  = 0x080;
    decay  = 0x110;
    stall  = 0x040;
    drive  = 0xA59;
  }

  void setChipSelectPin(uint8_t pin)
  {
    driver.setChipSelectPin(pin);
  }

  void resetSettings()
  {
    ctrl   = 0xC10;
    torque = 0x1FF;
    off    = 0x030;
    blank  = 0x080;
    decay  = 0x110;
    stall  = 0x040;
    drive  = 0xA59;
    applySettings();
  }

  bool verifySettings()
  {
    // Bit 10 in TORQUE is write-only and will always read as 0.
    return driver.readReg(HPSDRegAddr::CTRL)   == ctrl   &&
           driver.readReg(HPSDRegAddr::TORQUE) == (torque & ~(1 << 10)) &&
           driver.readReg(HPSDRegAddr::OFF)    == off    &&
           driver.readReg(HPSDRegAddr::BLANK)  == blank  &&
           driver.readReg(HPSDRegAddr::DECAY)  == decay  &&
           driver.readReg(HPSDRegAddr::STALL)  == stall  &&
           driver.readReg(HPSDRegAddr::DRIVE)  == drive;
  }

  void applySettings()
  {
    writeTORQUE();
    writeOFF();
    writeBLANK();
    writeDECAY();
    writeDRIVE();
    writeSTALL();
 
    // CTRL is written last because it contains the ENBL bit, and we want to try
    // to have all the other settings correct first.  (For example, TORQUE
    // defaults to 0xFF (the maximum value), so it would be better to set a more
    // appropriate value if necessary before enabling the motor.)
    writeCTRL();
  }

  void enableDriver()
  {
    ctrl |= (1 << 0);
    writeCTRL();
  }

  void disableDriver()
  {
    ctrl &= ~(1 << 0);
    writeCTRL();
  }

  void setDirection(bool value)
  {
    if (value)
    {
      ctrl |= (1 << 1);
    }
    else
    {
      ctrl &= ~(1 << 1);
    }
    writeCTRL();
  }

  bool getDirection()
  {
    return ctrl >> 1 & 1;
  }

  void step()
  {
    driver.writeReg(HPSDRegAddr::CTRL, ctrl | (1 << 2));
  }

  void setStepMode(HPSDStepMode mode)
  {
    // Pick 1/4 micro-step by default.
    uint8_t sm = 0b0010;
 
    switch (mode)
    {
    case HPSDStepMode::MicroStep1:   sm = 0b0000; break;
    case HPSDStepMode::MicroStep2:   sm = 0b0001; break;
    case HPSDStepMode::MicroStep4:   sm = 0b0010; break;
    case HPSDStepMode::MicroStep8:   sm = 0b0011; break;
    case HPSDStepMode::MicroStep16:  sm = 0b0100; break;
    case HPSDStepMode::MicroStep32:  sm = 0b0101; break;
    case HPSDStepMode::MicroStep64:  sm = 0b0110; break;
    case HPSDStepMode::MicroStep128: sm = 0b0111; break;
    case HPSDStepMode::MicroStep256: sm = 0b1000; break;
    }
 
    ctrl = (ctrl & 0b111110000111) | (sm << 3);
    writeCTRL();
  }

  void setStepMode(uint16_t mode)
  {
    setStepMode((HPSDStepMode)mode);
  }

  void setCurrentMilliamps36v4(uint16_t current)
  {
    if (current > 8000) { current = 8000; }
 
    // The 36v4 is just like the 36v8, except Risense is twice as large, so
    // TORQUE/ISGAIN has to be doubled.
    setCurrentMilliamps36v8(current * 2);
  }

  void setCurrentMilliamps36v8(uint16_t current)
  {
    if (current > 16000) { current = 16000; }
 
    // From the DRV8711 datasheet, section 7.3.4, equation 2:
    //
    //   Ifs = (2.75 V * TORQUE) / (256 * ISGAIN * Risense)
    //
    // Rearranged:
    //
    //   TORQUE = (256 * ISGAIN * Risense * Ifs) / 2.75 V
    //
    // The 36v8 has an Risense of 15 milliohms, and "current" is
    // in milliamps, so:
    //
    //   TORQUE = (256 * ISGAIN * (15/1000) ohms * (current/1000) A) / 2.75 V
    //          = (3840 * ISGAIN * current) / 2750000
    //          = (384 * (ISGAIN/40) * current) / 6875
    //
    // We want to pick the highest gain (5, 10, 20, or 40) that will not
    // overflow TORQUE (8 bits, 0xFF max), so we start with a gain of 40 and
    // calculate the TORQUE value needed.
    uint8_t isgainBits = 0b11;
    uint16_t torqueBits = ((uint32_t)384 * current) / 6875;
 
    // Halve the gain and TORQUE until the TORQUE value fits in 8 bits.
    while (torqueBits > 0xFF)
    {
      isgainBits--;
      torqueBits >>= 1;
    }
 
    ctrl = (ctrl & 0b110011111111) | (isgainBits << 8);
    writeCTRL();
    torque = (torque & 0b111100000000) | torqueBits;
    writeTORQUE();
  }

  void setDecayMode(HPSDDecayMode mode)
  {
    decay = (decay & 0b00011111111) | (((uint8_t)mode & 0b111) << 8);
    writeDECAY();
  }

  uint8_t readStatus()
  {
    return driver.readReg(HPSDRegAddr::STATUS);
  }

  void clearStatus()
  {
    driver.writeReg(HPSDRegAddr::STATUS, 0);
  }

  uint8_t readFaults()
  {
    return readStatus() & 0b00111111;
  }

  void clearFaults()
  {
    driver.writeReg(HPSDRegAddr::STATUS, ~0b00111111);
  }
 
protected:
 
  uint16_t ctrl, torque, off, blank, decay, stall, drive;

  void writeCTRL()
  {
    driver.writeReg(HPSDRegAddr::CTRL, ctrl);
  }

  void writeTORQUE()
  {
    driver.writeReg(HPSDRegAddr::TORQUE, torque);
  }

  void writeOFF()
  {
    driver.writeReg(HPSDRegAddr::OFF, off);
  }

  void writeBLANK()
  {
    driver.writeReg(HPSDRegAddr::BLANK, blank);
  }

  void writeDECAY()
  {
    driver.writeReg(HPSDRegAddr::DECAY, decay);
  }

  void writeSTALL()
  {
    driver.writeReg(HPSDRegAddr::STALL, stall);
  }

  void writeDRIVE()
  {
    driver.writeReg(HPSDRegAddr::DRIVE, drive);
  }
 
public:
  DRV8711SPI driver;
};