MP6602.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 MP6602RegAddr : uint8_t
{
  CTRL  = 0x00,
  CTRL2 = 0x01,
  ISET  = 0x02,
  STALL = 0x03,
  BEMF  = 0x04,
  TSTP  = 0x05,
  OCP   = 0x06,
  FAULT = 0x07,
};
 

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

  uint16_t readReg(uint8_t address)
  {
    // Arduino out / MP6602 in: first 3 bits = address, 4th bit = R/W (0 for
    // read); last 12 bits ignored
    // Arduino in / MP6602 out: first 4 bits undefined, then 12 bits of data read
    // out
 
    selectChip();
    uint16_t data = transfer16((uint16_t)(address & 0x7) << 13) & 0xFFF;
    deselectChip();
    return data;
  }

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

  void writeReg(uint8_t address, uint16_t value)
  {
    // Arduino out / MP6602 in: first 3 bits = address, 4th bit = R/W (1 for
    // write), then 12 data bits to be written
    // Arduino in / MP6602 out: undefined
 
    selectChip();
    transfer16(((uint16_t)(address & 0x7) << 13) | (1 << 12) | (value & 0xFFF));
    deselectChip();
  }

  void writeReg(MP6602RegAddr address, uint16_t value)
  {
    writeReg((uint8_t)address, value);
  }
 
private:
 
  // Max SPI frequency is 10 MHz. We use half that (5 MHz) to leave some margin
  // for timing inaccuracies.
  SPISettings settings = SPISettings(5000000, MSBFIRST, SPI_MODE0);
 
  uint16_t transfer16(uint16_t value)
  {
    return SPI.transfer16(value);
  }
 
  void selectChip()
  {
    digitalWrite(csPin, LOW);
    SPI.beginTransaction(settings);
  }
 
  void deselectChip()
  {
   SPI.endTransaction();
   digitalWrite(csPin, HIGH);
  }
 
  uint8_t csPin;
};
 

enum class MP6602StepMode : uint8_t
{
  MicroStep1     = 0b000, 
  MicroStep2     = 0b001, 
  MicroStep4     = 0b010, 
  MicroStep8     = 0b011, 
  MicroStep16    = 0b100, 
  MicroStep32    = 0b101, 
};

enum class MP6602FaultBit : uint8_t
{
  STALL = 9, 
  OLA   = 8, 
  OLB   = 7, 
  OCP   = 6, 
  OTS   = 5, 
  OTW   = 4, 
  OVP   = 3, 
  VINUV = 2, 
  VCCUV = 1, 
  FLT   = 0, 
};

enum class MP6602OCPBit : uint8_t
{
  OCPAH = 3, 
  OCPAL = 2, 
  OCPBH = 1, 
  OCPBL = 0, 
};
 

class MP6602
{
public:
  MP6602()
  {
    // All settings set to power-on defaults
    ctrl  = 0x118;
    ctrl2 = 0x034;
    iset  = 0x249;
    stall = 0x800;
    bemf  = 0x300;
  }

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

  void resetSettings()
  {
    ctrl  = 0x118;
    ctrl2 = 0x034;
    iset  = 0x249;
    stall = 0x800;
    bemf  = 0x300;
    applySettings();
 
    // Also restore the TSTP register (indexer step table position) to its reset
    // value.
    driver.writeReg(MP6602RegAddr::TSTP, 0x510);
  }

  bool verifySettings()
  {
    return driver.readReg(MP6602RegAddr::CTRL) == (ctrl & ~(1 << 1)) && // Bit 1 (STEP) is automatically reset to 0 (always reads as 0)
           driver.readReg(MP6602RegAddr::CTRL2) == ctrl2 &&
           driver.readReg(MP6602RegAddr::ISET)  == iset &&
           driver.readReg(MP6602RegAddr::STALL) == stall &&
           (driver.readReg(MP6602RegAddr::BEMF) & 0xF00) == (bemf & 0xF00); // Only verify bits 11:8, as bits 7:0 are BEMF measured value (not a driver setting) and read-only
  }

  void applySettings()
  {
    writeCachedReg(MP6602RegAddr::CTRL2);
    writeCachedReg(MP6602RegAddr::ISET);
    writeCachedReg(MP6602RegAddr::STALL);
    writeCachedReg(MP6602RegAddr::BEMF);
 
    // CTRL is written last because it contains the EN bit, and we want to try
    // to have all the other settings correct first.
    writeCachedReg(MP6602RegAddr::CTRL);
  }
 

  void setCurrentMilliamps(uint16_t current)
  {
    if (current > 4000) { current = 4000; }
    if (current < 125) { current = 125; }
 
    uint8_t is = (current - 125) / 125;
    iset = (iset & 0xFC0) | is;
    writeCachedReg(MP6602RegAddr::ISET);
  }

  void setHoldCurrentMilliamps(uint16_t current)
  {
    if (current > 4000) { current = 4000; }
    if (current < 125) { current = 125; }
 
    uint8_t il = (current - 125) / 125;
    iset = (iset & 0x03F) | ((uint16_t)il << 6);
    writeCachedReg(MP6602RegAddr::ISET);
  }

  void setAutoHoldTimeMs(uint16_t time)
  {
    uint8_t ah;
 
    if      (time ==   0) { ah = 0; } // disabled
    else if (time <=  15) { ah = 1; } //   15.6 ms
    else if (time <=  31) { ah = 2; } //   31.3 ms
    else if (time <=  62) { ah = 3; } //   62.5 ms
    else if (time <= 125) { ah = 4; } //  125   ms
    else if (time <= 250) { ah = 5; } //  250   ms
    else if (time <= 500) { ah = 6; } //  500   ms
    else                  { ah = 7; } // 1000   ms
 
    ctrl = (ctrl & 0x1FF) | ((uint16_t)ah << 9);
    writeCachedReg(MP6602RegAddr::CTRL);
  }

  void enableDriver()
  {
    ctrl |= 1;
    writeCachedReg(MP6602RegAddr::CTRL);
  }

  void disableDriver()
  {
    ctrl &= ~1;
    writeCachedReg(MP6602RegAddr::CTRL);
  }

  void setDirection(bool value)
  {
    if (value)
    {
      ctrl |= (1 << 2);
    }
    else
    {
      ctrl &= ~(1 << 2);
    }
    writeCachedReg(MP6602RegAddr::CTRL);
  }

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

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

  void setStepMode(MP6602StepMode mode)
  {
    if (mode > MP6602StepMode::MicroStep32)
    {
      // Invalid mode; pick 1/8-step by default.
      mode = MP6602StepMode::MicroStep8;
    }
 
    ctrl = (ctrl & 0xFC7) | ((uint8_t)mode << 3);
    writeCachedReg(MP6602RegAddr::CTRL);
  }

  void setStepMode(uint16_t mode)
  {
    MP6602StepMode sm;
 
    switch (mode)
    {
      case 1:   sm = MP6602StepMode::MicroStep1;   break;
      case 2:   sm = MP6602StepMode::MicroStep2;   break;
      case 4:   sm = MP6602StepMode::MicroStep4;   break;
      case 8:   sm = MP6602StepMode::MicroStep8;   break;
      case 16:  sm = MP6602StepMode::MicroStep16;  break;
      case 32:  sm = MP6602StepMode::MicroStep32;  break;
 
      // Invalid mode; pick 1/8-step by default.
      default:  sm = MP6602StepMode::MicroStep8;
    }
 
    setStepMode(sm);
  }

  uint16_t readFault()
  {
    return driver.readReg(MP6602RegAddr::FAULT) & 0x3FF;
  }

  uint8_t readOCP()
  {
    return driver.readReg(MP6602RegAddr::OCP) & 0xF;
  }

  void clearFaults()
  {
    // Write 1 to all OCP flag bits. Upper 8 bits of OCP are reserved, so keep
    // them the same as reset values.
    driver.writeReg(MP6602RegAddr::OCP, 0x55F);
 
    // Write 1 to all writable fault flag bits. Bits 11:10 are reserved, and OCP
    // (6) and FLT (0) are read-only (OR-ed from other bits).
    driver.writeReg(MP6602RegAddr::FAULT, 0x3BE);
  }

  uint16_t getCachedReg(MP6602RegAddr address)
  {
    uint16_t * cachedReg = cachedRegPtr(address);
    if (!cachedReg) { return 0; }
    return *cachedReg;
  }

  void setReg(MP6602RegAddr address, uint16_t value)
  {
    uint16_t * cachedReg = cachedRegPtr(address);
    if (!cachedReg) { return; }
    *cachedReg = value & 0xFFF;
    driver.writeReg(address, value);
  }
 
protected:
 
  uint16_t ctrl, ctrl2, iset, stall, bemf;

  uint16_t * cachedRegPtr(MP6602RegAddr address)
  {
    switch (address)
    {
      case MP6602RegAddr::CTRL:  return &ctrl;
      case MP6602RegAddr::CTRL2: return &ctrl2;
      case MP6602RegAddr::ISET:  return &iset;
      case MP6602RegAddr::STALL: return &stall;
      case MP6602RegAddr::BEMF:  return &bemf;
      default: return nullptr;
    }
  }

  void writeCachedReg(MP6602RegAddr address)
  {
    uint16_t * cachedReg = cachedRegPtr(address);
    if (!cachedReg) { return; }
    driver.writeReg(address, *cachedReg);
  }
 
public:
  MP6602SPI driver;
};