DRV8434S.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 DRV8434SRegAddr : uint8_t
{
  FAULT = 0x00,
  DIAG1 = 0x01,
  DIAG2 = 0x02,
  CTRL1 = 0x03,
  CTRL2 = 0x04,
  CTRL3 = 0x05,
  CTRL4 = 0x06,
  CTRL5 = 0x07,
  CTRL6 = 0x08,
  CTRL7 = 0x09,
  CTRL8 = 0x0A,
  CTRL9 = 0x0B,
};
 
 
class DRV8434SSPI
{
public:
  void setChipSelectPin(uint8_t pin)
  {
    csPin = pin;
    pinMode(csPin, OUTPUT);
    digitalWrite(csPin, HIGH);
  }
 
  uint8_t readReg(uint8_t address)
  {
    // Arduino out / DRV8434 in: First byte contains read/write bit and register
    // address; second byte is unused.
    // Arduino in / DRV8434 out: First byte contains status; second byte
    // contains data in register being read.
 
    selectChip();
    lastStatus = transfer((0x20 | (address & 0b11111)) << 1);
    uint8_t data = transfer(0);
    deselectChip();
    return data;
  }
 
  uint16_t readReg(DRV8434SRegAddr address)
  {
    return readReg((uint8_t)address);
  }
 
  uint8_t writeReg(uint8_t address, uint8_t value)
  {
    // Arduino out / DRV8434 in: First byte contains read/write bit and register
    // address; second byte contains data to write to register.
    // Arduino in / DRV8434 out: First byte contains status; second byte
    // contains old (existing) data in register being written to.
 
    selectChip();
    lastStatus = transfer((address & 0b11111) << 1);
    uint8_t oldData = transfer(value);
    // The CS line must go low after writing for the value to actually take
    // effect.
    deselectChip();
    return oldData;
  }
 
  void writeReg(DRV8434SRegAddr address, uint8_t value)
  {
    writeReg((uint8_t)address, value);
  }
 
private:
 
  SPISettings settings = SPISettings(500000, MSBFIRST, SPI_MODE1);
 
  uint8_t transfer(uint8_t value)
  {
    return SPI.transfer(value);
  }
 
  void selectChip()
  {
    digitalWrite(csPin, LOW);
    SPI.beginTransaction(settings);
  }
 
  void deselectChip()
  {
   SPI.endTransaction();
   digitalWrite(csPin, HIGH);
  }
 
  uint8_t csPin;
 
public:
 
  uint8_t lastStatus = 0;
};
 
 
enum class DRV8434SFaultBit : uint8_t
{
  FAULT = 7,
 
  SPI_ERROR = 6,
 
  UVLO = 5,
 
  CPUV = 4,
 
  OCP = 3,
 
  STL = 2,
 
  TF = 1,
 
  OL = 0,
};
 
enum class DRV8434SDiag1Bit : uint8_t
{
  OCP_LS2_B = 7,
 
  OCP_HS2_B = 6,
 
  OCP_LS1_B = 5,
 
  OCP_HS1_B = 4,
 
  OCP_LS2_A = 3,
 
  OCP_HS2_A = 2,
 
  OCP_LS1_A = 1,
 
  OCP_HS1_A = 0,
};
 
enum class DRV8434SDiag2Bit : uint8_t
{
  OTW = 6,
 
  OTS = 5,
 
  STL_LRN_OK = 4,
 
  STALL = 3,
 
  OL_B = 1,
 
  OL_A = 0,
};
 
enum class DRV8434SDecayMode : uint8_t
{
  Slow                   = 0b000,
  IncSlowDecMixed30      = 0b001,
  IncSlowDecMixed60      = 0b010,
  IncSlowDecFast         = 0b011,
  Mixed30                = 0b100,
  Mixed60                = 0b101,
  SmartTuneDynamicDecay  = 0b110,
  SmartTuneRippleControl = 0b111,
};
 
enum class DRV8434SStepMode : uint8_t
{
  MicroStep1_100 = 0b0000,
 
  MicroStep1     = 0b0001,
 
  MicroStep2_NC  = 0b0010,
 
  MicroStep2     = 0b0011,
 
  MicroStep4     = 0b0100,
  MicroStep8     = 0b0101,
  MicroStep16    = 0b0110,
  MicroStep32    = 0b0111,
  MicroStep64    = 0b1000,
  MicroStep128   = 0b1001,
  MicroStep256   = 0b1010,
};
 
 
class DRV8434S
{
public:
  DRV8434S()
  {
    // All settings set to power-on defaults
    ctrl1 = 0x00;
    ctrl2 = 0x0F;
    ctrl3 = 0x06;
    ctrl4 = 0x30;
    ctrl5 = 0x08;
    ctrl6 = 0x03;
    ctrl7 = 0x20;
  }
 
  void setChipSelectPin(uint8_t pin)
  {
    driver.setChipSelectPin(pin);
  }
 
  void resetSettings()
  {
    ctrl1 = 0x00;
    ctrl2 = 0x0F;
    ctrl3 = 0x06;
    ctrl4 = 0x30;
    ctrl5 = 0x08;
    ctrl6 = 0x03;
    ctrl7 = 0x20;
    applySettings();
  }
 
  bool verifySettings()
  {
    return driver.readReg(DRV8434SRegAddr::CTRL1) == ctrl1 &&
           driver.readReg(DRV8434SRegAddr::CTRL2) == ctrl2 &&
           driver.readReg(DRV8434SRegAddr::CTRL3) == ctrl3 &&
           driver.readReg(DRV8434SRegAddr::CTRL4) == ctrl4 &&
           driver.readReg(DRV8434SRegAddr::CTRL5) == ctrl5 &&
           driver.readReg(DRV8434SRegAddr::CTRL6) == ctrl6 &&
           driver.readReg(DRV8434SRegAddr::CTRL7) == ctrl7;
  }
 
  void applySettings()
  {
    writeCachedReg(DRV8434SRegAddr::CTRL1);
    writeCachedReg(DRV8434SRegAddr::CTRL3);
    writeCachedReg(DRV8434SRegAddr::CTRL4);
    writeCachedReg(DRV8434SRegAddr::CTRL5);
    writeCachedReg(DRV8434SRegAddr::CTRL6);
    writeCachedReg(DRV8434SRegAddr::CTRL7);
 
    // CTRL2 is written last because it contains the EN_OUT bit, and we want to
    // try to have all the other settings correct first.
    writeCachedReg(DRV8434SRegAddr::CTRL2);
  }
 
  void setCurrentPercent(uint8_t percent)
  {
    if (percent > 100) { percent = 100; }
    if (percent < 6) { percent = 6; }
 
    uint8_t td = ((uint16_t)percent * 4 + 3) / 25; // convert 6-100% to 1-16, rounding up by at most 0.75%
    td = 16 - td;                                  // convert 1-16 to 15-0 (15 = 6.25%, 0 = 100%)
    ctrl1 = (ctrl1 & 0b00001111) | (td << 4);
    writeCachedReg(DRV8434SRegAddr::CTRL1);
  }
 
  void setCurrentMilliamps(uint16_t current, uint16_t fullCurrent = 2000)
  {
    if (fullCurrent > 4000) { fullCurrent = 4000; }
    if (current > fullCurrent) { current = fullCurrent; }
 
    uint8_t td = (current * 16 / fullCurrent); // convert 0-fullCurrent to 0-16
    if (td == 0) { td = 1; }                   // restrict to 1-16
    td = 16 - td;                              // convert 1-16 to 15-0 (15 = 6.25%, 0 = 100%)
    ctrl1 = (ctrl1 & 0b00001111) | (td << 4);
    writeCachedReg(DRV8434SRegAddr::CTRL1);
  }
 
  void enableDriver()
  {
    ctrl2 |= (1 << 7);
    writeCachedReg(DRV8434SRegAddr::CTRL2);
  }
 
  void disableDriver()
  {
    ctrl2 &= ~(1 << 7);
    writeCachedReg(DRV8434SRegAddr::CTRL2);
  }
 
  void setDecayMode(DRV8434SDecayMode mode)
  {
    ctrl2 = (ctrl2 & 0b11111000) | (((uint8_t)mode & 0b111) << 8);
    writeCachedReg(DRV8434SRegAddr::CTRL2);
  }
 
  void setDirection(bool value)
  {
    if (value)
    {
      ctrl3 |= (1 << 7);
    }
    else
    {
      ctrl3 &= ~(1 << 7);
    }
    writeCachedReg(DRV8434SRegAddr::CTRL3);
  }
 
  bool getDirection()
  {
    return (ctrl3 >> 7) & 1;
  }
 
  void step()
  {
    driver.writeReg(DRV8434SRegAddr::CTRL3, ctrl3 | (1 << 6));
  }
 
  void enableSPIDirection()
  {
    ctrl3 |= (1 << 5);
    writeCachedReg(DRV8434SRegAddr::CTRL3);
  }
 
  void disableSPIDirection()
  {
    ctrl3 &= ~(1 << 5);
    writeCachedReg(DRV8434SRegAddr::CTRL3);
  }
 
  void enableSPIStep()
  {
    ctrl3 |= (1 << 4);
    writeCachedReg(DRV8434SRegAddr::CTRL3);
  }
 
  void disableSPIStep()
  {
    ctrl3 &= ~(1 << 4);
    writeCachedReg(DRV8434SRegAddr::CTRL3);
  }
 
  void setStepMode(DRV8434SStepMode mode)
  {
    if (mode > DRV8434SStepMode::MicroStep256)
    {
      // Invalid mode; pick 1/16 micro-step by default.
      mode = DRV8434SStepMode::MicroStep16;
    }
 
    ctrl3 = (ctrl3 & 0b11110000) | (uint8_t)mode;
    writeCachedReg(DRV8434SRegAddr::CTRL3);
  }
 
  void setStepMode(uint16_t mode)
  {
    DRV8434SStepMode sm;
 
    switch (mode)
    {
      case 1:   sm = DRV8434SStepMode::MicroStep1;   break;
      case 2:   sm = DRV8434SStepMode::MicroStep2;   break;
      case 4:   sm = DRV8434SStepMode::MicroStep4;   break;
      case 8:   sm = DRV8434SStepMode::MicroStep8;   break;
      case 16:  sm = DRV8434SStepMode::MicroStep16;  break;
      case 32:  sm = DRV8434SStepMode::MicroStep32;  break;
      case 64:  sm = DRV8434SStepMode::MicroStep64;  break;
      case 128: sm = DRV8434SStepMode::MicroStep128; break;
      case 256: sm = DRV8434SStepMode::MicroStep256; break;
 
      // Invalid mode; pick 1/16 micro-step by default.
      default:  sm = DRV8434SStepMode::MicroStep16;
    }
 
    setStepMode(sm);
  }
 
  uint8_t readFault()
  {
    return driver.readReg(DRV8434SRegAddr::FAULT);
  }
 
  uint8_t readDiag1()
  {
    return driver.readReg(DRV8434SRegAddr::DIAG1);
  }
 
  uint8_t readDiag2()
  {
    return driver.readReg(DRV8434SRegAddr::DIAG2);
  }
 
  void clearFaults()
  {
    driver.writeReg(DRV8434SRegAddr::CTRL4, ctrl4 | (1 << 7));
  }
 
  uint8_t getCachedReg(DRV8434SRegAddr address)
  {
    uint8_t * cachedReg = cachedRegPtr(address);
    if (!cachedReg) { return 0; }
    return *cachedReg;
  }
 
  void setReg(DRV8434SRegAddr address, uint8_t value)
  {
    uint8_t * cachedReg = cachedRegPtr(address);
    if (!cachedReg) { return; }
    *cachedReg = value;
    driver.writeReg(address, value);
  }
 
protected:
 
  uint8_t ctrl1, ctrl2, ctrl3, ctrl4, ctrl5, ctrl6, ctrl7;
 
  uint8_t * cachedRegPtr(DRV8434SRegAddr address)
  {
    switch (address)
    {
      case DRV8434SRegAddr::CTRL1: return &ctrl1;
      case DRV8434SRegAddr::CTRL2: return &ctrl2;
      case DRV8434SRegAddr::CTRL3: return &ctrl3;
      case DRV8434SRegAddr::CTRL4: return &ctrl4;
      case DRV8434SRegAddr::CTRL5: return &ctrl5;
      case DRV8434SRegAddr::CTRL6: return &ctrl6;
      case DRV8434SRegAddr::CTRL7: return &ctrl7;
      default: return nullptr;
    }
  }
 
  void writeCachedReg(DRV8434SRegAddr address)
  {
    uint8_t * cachedReg = cachedRegPtr(address);
    if (!cachedReg) { return; }
    driver.writeReg(address, *cachedReg);
  }
 
public:
  DRV8434SSPI driver;
};