drv8704.h

Go to the documentation of this file.

 
#ifndef DRV8704_H
#define DRV8704_H
 
#include <Arduino.h>
#include <SPI.h>
 
#include "drv8704_defs.h"
#include "drv8704_types.h"
#include "drv8704_regs_typedefs.h"
 
class DRV8704PwmBackend;
 
class DRV8704 {
public:
  explicit DRV8704(const DRV8704Pins& pins, SPIClass& spi = SPI);
 
  bool begin();
 
  void end();
 
  void sleep();
 
  void wake();
 
  void reset();
 
  uint16_t readRegister(uint8_t address);
 
  uint16_t readRegister(RegisterAddress address) {
    return readRegister(static_cast<uint8_t>(address));
  }
 
  bool writeRegister(uint8_t address, uint16_t value);
 
  bool writeRegister(RegisterAddress address, uint16_t value) {
    return writeRegister(static_cast<uint8_t>(address), value);
  }
 
  bool updateRegister(uint8_t address, uint16_t mask, uint16_t value);
 
  bool updateRegister(RegisterAddress address, uint16_t mask, uint16_t value) {
    return updateRegister(static_cast<uint8_t>(address), mask, value);
  }
 
  bool enableBridgeDriver(bool enabled);
 
  bool setSenseGain(SenseGain gain);
 
  bool setDeadTime(DeadTime deadTime);
 
  bool setTorque(uint8_t torque);
 
  bool setOffTime(uint8_t offTime);
 
  bool setBlankTime(uint8_t blankTime);
 
  bool setDecayMode(DecayMode mode);
 
  bool setDecayTime(uint8_t decayTime);
 
  bool setOcpThreshold(OcpThreshold threshold);
 
  bool setOcpDeglitch(OcpDeglitch deglitch);
 
  bool setGateDriveTimes(GateDriveTime tDriveN, GateDriveTime tDriveP);
 
  bool setGateDriveCurrents(GateDriveSinkCurrent iDriveN, GateDriveSourceCurrent iDriveP);
 
  bool setGateDrive(const GateDriveConfig& gateDrive);
 
  bool applyConfig(const DRV8704Config& config);
 
  bool setShuntResistance(float ohms);
 
  bool setShuntResistance(BridgeId bridge, float ohms);
 
  bool setCurrentModePreset(CurrentModePreset preset);
 
  bool setDirection(BridgeId bridge, Direction direction);
 
  Direction direction(BridgeId bridge) const;
 
  bool setCurrentLimit(float amps);
 
  bool setCurrent(BridgeId bridge, float amps);
 
  bool disableCurrentLimit();
 
  bool isCurrentLimitEnabled() const { return currentLimitEnabled_; }
 
  DRV8704CurrentPresetConfig currentModePresetConfig() const { return currentPresetConfig_; }
 
  DRV8704CurrentLimitResult currentLimitResult() const { return currentLimitResult_; }
 
  DRV8704Status readStatus();
 
  bool hasFault();
 
  bool hasFaultPin() const { return pins_.faultPin >= 0; }
 
  bool isFaultPinActive() const;
 
  bool clearFaults();
 
  bool clearFault(FaultBit bit);
 
  void coast(BridgeId bridge);
 
  void brake(BridgeId bridge);
 
  void setBridgeMode(BridgeId bridge, BridgeMode mode);
 
  DRV8704BridgeState bridgeState(BridgeId bridge) const;
 
  bool beginPwmMode(const DRV8704PwmConfig& config = DRV8704PwmConfig());
 
  void endPwmMode();
 
  bool setPwmFrequency(uint32_t frequencyHz);
 
  bool setSpeed(BridgeId bridge, float speedPercent);
 
  bool setSpeed(BridgeId bridge, Direction direction, float speedPercent) {
    return setDirection(bridge, direction) && setSpeed(bridge, speedPercent);
  }
 
  bool setCurrent(BridgeId bridge, Direction direction, float amps) {
    return setDirection(bridge, direction) && setCurrent(bridge, amps);
  }
 
  DRV8704PwmCapability pwmCapability() const { return pwmCapability_; }
 
  float smallestDutyIncrementPercent() const {
    return pwmCapability_.smallestDutyIncrementPercent;
  }
 
  bool isPwmModeEnabled() const { return pwmModeEnabled_; }
 
  DRV8704HealthCheck healthCheck();
 
  bool isInitialized() const { return initialized_; }
 
  uint16_t cachedRegister(uint8_t address) const;
 
  bool syncRegisterCache();
 
private:
  bool isValidAddress(uint8_t address) const;
 
  bool writeRegisterVerified(uint8_t address, uint16_t value, uint16_t verifyMask);
 
  bool updateRegisterVerified(uint8_t address, uint16_t mask, uint16_t value, uint16_t verifyMask);
 
  void seedDefaultRegisterCache();
 
  bool checkDefaultRegisters(uint8_t& matchCount);
 
  void logDefaultRegisterMismatch(uint8_t address, uint16_t expected, uint16_t actual) const;
 
  float senseGainValue(SenseGain gain) const;
 
  float shuntResistance(BridgeId bridge) const;
 
  float currentLimitReferenceShunt() const;
 
  DRV8704CurrentPresetConfig presetConfig(CurrentModePreset preset, uint32_t pwmFrequencyHz) const;
 
  bool deriveCurrentLimit(float amps, DRV8704CurrentLimitResult& result) const;
 
  bool applyCurrentLimitResult(const DRV8704CurrentLimitResult& result, uint32_t pwmFrequencyHz);
 
  bool applyBridgeState(BridgeId bridge);
 
  bool performWriteReadbackProbe();
 
  void beginTransaction();
 
  void endTransaction();
 
  uint16_t transferFrame(uint16_t frame);
 
  void setBridgePins(int8_t in1Pin, int8_t in2Pin, BridgeMode mode);
 
  void setBridgeStaticMode(BridgeId bridge, BridgeMode mode);
 
  bool setBridgePwm(int8_t in1Pin, int8_t in2Pin, Direction direction, float speedPercent);
 
  DRV8704Pins pins_;
  SPIClass* spi_;
  SPISettings spiSettings_;
  uint16_t registerCache_[DRV8704_REGISTER_COUNT];
  float shuntOhms_[2];
  Direction bridgeDirections_[2];
  DRV8704BridgeState bridgeStates_[2];
  float bridgeSpeedPercents_[2];
  CurrentModePreset currentPreset_;
  DRV8704CurrentPresetConfig currentPresetConfig_;
  DRV8704CurrentLimitResult currentLimitResult_;
  bool currentLimitEnabled_;
  DRV8704PwmBackend* pwmBackend_;
  DRV8704PwmConfig pwmConfig_;
  DRV8704PwmCapability pwmCapability_;
  bool pwmModeEnabled_;
  bool initialized_;
};
 
#endif // DRV8704_H