JrkG2.h

Go to the documentation of this file.

// Copyright (C) Pololu Corporation.  See LICENSE.txt for details.


#pragma once

#include <Arduino.h>
#include <Stream.h>
#include <Wire.h>

const uint16_t JrkG2InputNull = 0xFFFF;

const uint8_t JrkG2CommReadError = 50;

enum class JrkG2Error
{
  AwaitingCommand     = 0,
  NoPower             = 1,
  MotorDriver         = 2,
  InputInvalid        = 3,
  InputDisconnect     = 4,
  FeedbackDisconnect  = 5,
  SoftOvercurrent     = 6,
  SerialSignal        = 7,
  SerialOverrun       = 8,
  SerialBufferFull    = 9,
  SerialCrc           = 10,
  SerialProtocol      = 11,
  SerialTimeout       = 12,
  HardOvercurrent     = 13,
};

enum class JrkG2Command
{
  SetTarget                         = 0xC0,
  SetTargetLowResRev                = 0xE0,
  SetTargetLowResFwd                = 0xE1,
  ForceDutyCycleTarget              = 0xF2,
  ForceDutyCycle                    = 0xF4,
  MotorOff                          = 0xFF,
  GetVariable8                      = 0x80,
  GetVariable16                     = 0xA0,
  GetEEPROMSettings                 = 0xE3,
  GetVariables                      = 0xE5,
  SetRAMSettings                    = 0xE6,
  GetRAMSettings                    = 0xEA,
  GetCurrentChoppingOccurrenceCount = 0xEC,
};

enum class JrkG2ForceMode
{
  None            = 0,
  DutyCycleTarget = 1,
  DutyCycle       = 2,
};

enum class JrkG2Reset
{
  PowerUp        = 0,
  Brownout       = 1,
  ResetLine      = 2,
  Watchdog       = 4,
  Software       = 8,
  StackOverflow  = 16,
  StackUnderflow = 32,
};

enum class JrkG2Pin
{
  SCL = 0,
  SDA = 1,
  TX  = 2,
  RX  = 3,
  RC  = 4,
  AUX = 5,
  FBA = 6,
  FBT = 7,
};

enum class JrkG2OptionsByte3
{
  ResetIntegral = 0,
  CoastWhenOff = 1,
};

class JrkG2Base
{
public:
  uint8_t getLastError()
  {
    return _lastError;
  }


  void setTarget(uint16_t target)
  {
    // lower 5 bits in command byte
    // upper 7 bits in data byte
    if (target > 4095) { target = 4095; }
    commandW7((uint8_t)JrkG2Command::SetTarget | (target & 0x1F), target >> 5);
  }

  void setTargetLowResRev(uint8_t target)
  {
    if (target > 127) { target = 127; }
    commandW7(JrkG2Command::SetTargetLowResRev, target);
  }

  void setTargetLowResFwd(uint8_t target)
  {
    if (target > 127) { target = 127; }
    commandW7(JrkG2Command::SetTargetLowResFwd, target);
  }

  void forceDutyCycleTarget(int16_t dutyCycle)
  {
    if (dutyCycle > 600) { dutyCycle = 600; }
    if (dutyCycle < -600) { dutyCycle = -600; }
    commandWs14(JrkG2Command::ForceDutyCycleTarget, dutyCycle);
  }

  void forceDutyCycle(int16_t dutyCycle)
  {
    if (dutyCycle > 600) { dutyCycle = 600; }
    if (dutyCycle < -600) { dutyCycle = -600; }
    commandWs14(JrkG2Command::ForceDutyCycle, dutyCycle);
  }

  void stopMotor()
  {
    commandQuick(JrkG2Command::MotorOff);
  }



  uint16_t getInput()
  {
    return getVar16SingleByte(VarOffset::Input);
  }

  uint16_t getTarget()
  {
    return getVar16SingleByte(VarOffset::Target);
  }

  uint16_t getFeedback()
  {
    return getVar16SingleByte(VarOffset::Feedback);
  }

  uint16_t getScaledFeedback()
  {
    return getVar16SingleByte(VarOffset::ScaledFeedback);
  }

  int16_t getIntegral()
  {
    return getVar16SingleByte(VarOffset::Integral);
  }

  int16_t getDutyCycleTarget()
  {
    return getVar16SingleByte(VarOffset::DutyCycleTarget);
  }

  int16_t getDutyCycle()
  {
    return getVar16SingleByte(VarOffset::DutyCycle);
  }

  uint8_t getCurrentLowRes()
  {
    return getVar8SingleByte(VarOffset::CurrentLowRes);
  }

  bool getPIDPeriodExceeded()
  {
    return getVar8SingleByte(VarOffset::PIDPeriodExceeded);
  }

  uint16_t getPIDPeriodCount()
  {
    return getVar16SingleByte(VarOffset::PIDPeriodCount);
  }

  uint16_t getErrorFlagsHalting()
  {
    return getVar16SingleByte(VarOffset::ErrorFlagsHalting);
  }

  uint16_t getErrorFlagsOccurred()
  {
    return getVar16SingleByte(VarOffset::ErrorFlagsOccurred);
  }

  JrkG2ForceMode getForceMode()
  {
    return (JrkG2ForceMode)(getVar8SingleByte(VarOffset::FlagByte1) & 0x03);
  }

  uint16_t getVinVoltage()
  {
    return getVar16SingleByte(VarOffset::VinVoltage);
  }

  uint16_t getCurrent()
  {
    return getVar16SingleByte(VarOffset::Current);
  }

  JrkG2Reset getDeviceReset()
  {
    return (JrkG2Reset)getVar8(VarOffset::DeviceReset);
  }

  uint32_t getUpTime()
  {
    return getVar32(VarOffset::UpTime);
  }

  uint16_t getRCPulseWidth()
  {
    return getVar16(VarOffset::RCPulseWidth);
  }

  uint16_t getFBTReading()
  {
    return getVar16(VarOffset::FBTReading);
  }

  uint16_t getAnalogReading(JrkG2Pin pin)
  {
    switch (pin)
    {
    case JrkG2Pin::SDA:
      return getVar16(VarOffset::AnalogReadingSDA);
    case JrkG2Pin::FBA:
      return getVar16(VarOffset::AnalogReadingFBA);
    default:
      return JrkG2InputNull;
    }
  }

  bool getDigitalReading(JrkG2Pin pin)
  {
    uint8_t readings = getVar8(VarOffset::DigitalReadings);
    return (readings >> (uint8_t)pin) & 1;
  }

  uint16_t getRawCurrent()
  {
    return getVar16(VarOffset::RawCurrent);
  }

  uint16_t getEncodedHardCurrentLimit()
  {
    return getVar16(VarOffset::EncodedHardCurrentLimit);
  }

  int16_t getLastDutyCycle()
  {
    return getVar16(VarOffset::LastDutyCycle);
  }

  uint8_t getCurrentChoppingConsecutiveCount()
  {
    return getVar8(VarOffset::CurrentChoppingConsecutiveCount);
  }

  uint8_t getCurrentChoppingOccurrenceCount()
  {
    return commandR8(JrkG2Command::GetCurrentChoppingOccurrenceCount);
  }


  void setResetIntegral(bool reset)
  {
    uint8_t tmp = getRAMSetting8(SettingOffset::OptionsByte3);
    if (getLastError()) { return; }
    if (reset)
    {
      tmp |= 1 << (uint8_t)JrkG2OptionsByte3::ResetIntegral;
    }
    else
    {
      tmp &= ~(1 << (uint8_t)JrkG2OptionsByte3::ResetIntegral);
    }
    setRAMSetting8(SettingOffset::OptionsByte3, tmp);
  }

  bool getResetIntegral()
  {
    return getRAMSetting8(SettingOffset::OptionsByte3) >>
      (uint8_t)JrkG2OptionsByte3::ResetIntegral & 1;
  }

  void setCoastWhenOff(bool coast)
  {
    uint8_t tmp = getRAMSetting8(SettingOffset::OptionsByte3);
    if (getLastError()) { return; }
    if (coast)
    {
      tmp |= 1 << (uint8_t)JrkG2OptionsByte3::CoastWhenOff;
    }
    else
    {
      tmp &= ~(1 << (uint8_t)JrkG2OptionsByte3::CoastWhenOff);
    }
    setRAMSetting8(SettingOffset::OptionsByte3, tmp);
  }

  bool getCoastWhenOff()
  {
    return getRAMSetting8(SettingOffset::OptionsByte3) >>
      (uint8_t)JrkG2OptionsByte3::CoastWhenOff & 1;
  }

  void setProportionalCoefficient(uint16_t multiplier, uint8_t exponent)
  {
    setPIDCoefficient(SettingOffset::ProportionalMultiplier, multiplier, exponent);
  }

  uint16_t getProportionalMultiplier()
  {
    return getRAMSetting16(SettingOffset::ProportionalMultiplier);
  }

  uint8_t getProportionalExponent()
  {
    return getRAMSetting8(SettingOffset::ProportionalExponent);
  }

  void setIntegralCoefficient(uint16_t multiplier, uint8_t exponent)
  {
    setPIDCoefficient(SettingOffset::IntegralMultiplier, multiplier, exponent);
  }

  uint16_t getIntegralMultiplier()
  {
    return getRAMSetting16(SettingOffset::IntegralMultiplier);
  }

  uint8_t getIntegralExponent()
  {
    return getRAMSetting8(SettingOffset::IntegralExponent);
  }

  void setDerivativeCoefficient(uint16_t multiplier, uint8_t exponent)
  {
    setPIDCoefficient(SettingOffset::DerivativeMultiplier, multiplier, exponent);
  }

  uint16_t getDerivativeMultiplier()
  {
    return getRAMSetting16(SettingOffset::DerivativeMultiplier);
  }

  uint8_t getDerivativeExponent()
  {
    return getRAMSetting8(SettingOffset::DerivativeExponent);
  }

  void setPIDPeriod(uint16_t period)
  {
    setRAMSetting16(SettingOffset::PIDPeriod, period);
  }

  uint16_t getPIDPeriod()
  {
    return getRAMSetting16(SettingOffset::PIDPeriod);
  }

  void setIntegralLimit(uint16_t limit)
  {
    setRAMSetting16(SettingOffset::IntegralLimit, limit);
  }

  uint16_t getIntegralLimit()
  {
    return getRAMSetting16(SettingOffset::IntegralLimit);
  }

  void setMaxDutyCycleWhileFeedbackOutOfRange(uint16_t duty)
  {
    setRAMSetting16(SettingOffset::MaxDutyCycleWhileFeedbackOutOfRange, duty);
  }

  uint16_t getMaxDutyCycleWhileFeedbackOutOfRange()
  {
    return getRAMSetting16(SettingOffset::MaxDutyCycleWhileFeedbackOutOfRange);
  }

  void setMaxAccelerationForward(uint16_t accel)
  {
    setRAMSetting16(SettingOffset::MaxAccelerationForward, accel);
  }

  uint16_t getMaxAccelerationForward()
  {
    return getRAMSetting16(SettingOffset::MaxAccelerationForward);
  }

  void setMaxAccelerationReverse(uint16_t accel)
  {
    setRAMSetting16(SettingOffset::MaxAccelerationReverse, accel);
  }

  uint16_t getMaxAccelerationReverse()
  {
    return getRAMSetting16(SettingOffset::MaxAccelerationReverse);
  }

  void setMaxAcceleration(uint16_t accel)
  {
    setRAMSetting16x2(SettingOffset::MaxAccelerationForward, accel, accel);
  }

  void setMaxDecelerationForward(uint16_t decel)
  {
    setRAMSetting16(SettingOffset::MaxDecelerationForward, decel);
  }

  uint16_t getMaxDecelerationForward()
  {
    return getRAMSetting16(SettingOffset::MaxDecelerationForward);
  }

  void setMaxDecelerationReverse(uint16_t decel)
  {
    setRAMSetting16(SettingOffset::MaxDecelerationReverse, decel);
  }

  uint16_t getMaxDecelerationReverse()
  {
    return getRAMSetting16(SettingOffset::MaxDecelerationReverse);
  }

  void setMaxDeceleration(uint16_t decel)
  {
    setRAMSetting16x2(SettingOffset::MaxDecelerationForward, decel, decel);
  }

  void setMaxDutyCycleForward(uint16_t duty)
  {
    setRAMSetting16(SettingOffset::MaxDutyCycleForward, duty);
  }

  uint16_t getMaxDutyCycleForward()
  {
    return getRAMSetting16(SettingOffset::MaxDutyCycleForward);
  }

  void setMaxDutyCycleReverse(uint16_t duty)
  {
    setRAMSetting16(SettingOffset::MaxDutyCycleReverse, duty);
  }

  uint16_t getMaxDutyCycleReverse()
  {
    return getRAMSetting16(SettingOffset::MaxDutyCycleReverse);
  }

  void setMaxDutyCycle(uint16_t duty)
  {
    setRAMSetting16x2(SettingOffset::MaxDutyCycleForward, duty, duty);
  }

  void setEncodedHardCurrentLimitForward(uint16_t encoded_limit)
  {
    setRAMSetting16(SettingOffset::EncodedHardCurrentLimitForward,
      encoded_limit);
  }

  uint16_t getEncodedHardCurrentLimitForward()
  {
    return getRAMSetting16(SettingOffset::EncodedHardCurrentLimitForward);
  }

  void setEncodedHardCurrentLimitReverse(uint16_t encoded_limit)
  {
    setRAMSetting16(SettingOffset::EncodedHardCurrentLimitReverse, encoded_limit);
  }

  uint16_t getEncodedHardCurrentLimitReverse()
  {
    return getRAMSetting16(SettingOffset::EncodedHardCurrentLimitReverse);
  }

  void setEncodedHardCurrentLimit(uint16_t encoded_limit)
  {
    setRAMSetting16x2(SettingOffset::EncodedHardCurrentLimitForward,
      encoded_limit, encoded_limit);
  }

  void setBrakeDurationForward(uint8_t duration)
  {
    setRAMSetting8(SettingOffset::BrakeDurationForward, duration);
  }

  uint8_t getBrakeDurationForward()
  {
    return getRAMSetting8(SettingOffset::BrakeDurationForward);
  }

  void setBrakeDurationReverse(uint8_t duration)
  {
    setRAMSetting8(SettingOffset::BrakeDurationReverse, duration);
  }

  uint8_t getBrakeDurationReverse()
  {
    return getRAMSetting8(SettingOffset::BrakeDurationReverse);
  }

  void setBrakeDuration(uint8_t duration)
  {
    setRAMSetting8x2(SettingOffset::BrakeDurationForward, duration, duration);
  }

  void setSoftCurrentLimitForward(uint16_t current)
  {
    setRAMSetting16(SettingOffset::SoftCurrentLimitForward, current);
  }

  uint16_t getSoftCurrentLimitForward()
  {
    return getRAMSetting16(SettingOffset::SoftCurrentLimitForward);
  }

  void setSoftCurrentLimitReverse(uint16_t current)
  {
    setRAMSetting16(SettingOffset::SoftCurrentLimitReverse, current);
  }

  uint16_t getSoftCurrentLimitReverse()
  {
    return getRAMSetting16(SettingOffset::SoftCurrentLimitReverse);
  }

  void setSoftCurrentLimit(uint16_t current)
  {
    setRAMSetting16x2(SettingOffset::SoftCurrentLimitForward, current, current);
  }

  // TODO: add functions to get and set the soft current regulation level



  void getEEPROMSettings(uint8_t offset, uint8_t length, uint8_t * buffer)
  {
    segmentRead(JrkG2Command::GetEEPROMSettings, offset, length, buffer);
  }

  void getRAMSettings(uint8_t offset, uint8_t length, uint8_t * buffer)
  {
    segmentRead(JrkG2Command::GetRAMSettings, offset, length, buffer);
  }

  void setRAMSettings(uint8_t offset, uint8_t length, uint8_t * buffer)
  {
    segmentWrite(JrkG2Command::SetRAMSettings, offset, length, buffer);
  }

  void getVariables(uint8_t offset, uint8_t length, uint8_t * buffer)
  {
    segmentRead(JrkG2Command::GetVariables, offset, length, buffer);
  }


protected:
  uint8_t _lastError = 0;

private:
  enum VarOffset
  {
    Input                           = 0x00, // uint16_t
    Target                          = 0x02, // uint16_t
    Feedback                        = 0x04, // uint16_t
    ScaledFeedback                  = 0x06, // uint16_t
    Integral                        = 0x08, // int16_t
    DutyCycleTarget                 = 0x0A, // int16_t
    DutyCycle                       = 0x0C, // int16_t
    CurrentLowRes                   = 0x0E, // uint8_t
    PIDPeriodExceeded               = 0x0F, // uint8_t
    PIDPeriodCount                  = 0x10, // uint16_t
    ErrorFlagsHalting               = 0x12, // uint16_t
    ErrorFlagsOccurred              = 0x14, // uint16_t

    FlagByte1                       = 0x16, // uint8_t
    VinVoltage                      = 0x17, // uint16_t
    Current                         = 0x19, // uint16_t

    // variables above can be read with single-byte commands (GetVariable)
    // variables below must be read with segment read (GetVariables)

    DeviceReset                     = 0x1F, // uint8_t
    UpTime                          = 0x20, // uint32_t
    RCPulseWidth                    = 0x24, // uint16_t
    FBTReading                      = 0x26, // uint16_t
    AnalogReadingSDA                = 0x28, // uint16_t
    AnalogReadingFBA                = 0x2A, // uint16_t
    DigitalReadings                 = 0x2C, // uint8_t
    RawCurrent                      = 0x2D, // uint16_t
    EncodedHardCurrentLimit         = 0x2F, // uint16_t
    LastDutyCycle                   = 0x31, // int16_t
    CurrentChoppingConsecutiveCount = 0x33, // uint8_t
    CurrentChoppingOccurrenceCount  = 0x34, // uint8_t; read with dedicated command
  };

  enum SettingOffset
  {
    OptionsByte1                        = 0x01,  // uint8_t
    OptionsByte2                        = 0x02,  // uint8_t
    InputMode                           = 0x03,  // uint8_t
    InputErrorMinimum                   = 0x04,  // uint16_t,
    InputErrorMaximum                   = 0x06,  // uint16_t,
    InputMinimum                        = 0x08,  // uint16_t,
    InputMaximum                        = 0x0A,  // uint16_t,
    InputNeutralMinimum                 = 0x0C,  // uint16_t,
    InputNeutralMaximum                 = 0x0E,  // uint16_t,
    OutputMinimum                       = 0x10,  // uint16_t,
    OutputNeutral                       = 0x12,  // uint16_t,
    OutputMaximum                       = 0x14,  // uint16_t,
    InputScalingDegree                  = 0x16,  // uint8_t,
    InputAnalogSamplesExponent          = 0x17,  // uint8_t,
    FeedbackMode                        = 0x18,  // uint8_t,
    FeedbackErrorMinimum                = 0x19,  // uint16_t,
    FeedbackErrorMaximum                = 0x1B,  // uint16_t,
    FeedbackMinimum                     = 0x1D,  // uint16_t,
    FeedbackMaximum                     = 0x1F,  // uint16_t,
    FeedbackDeadZone                    = 0x21,  // uint8_t,
    FeedbackAnalogSamplesExponent       = 0x22,  // uint8_t,
    SerialMode                          = 0x23,  // uint8_t,
    SerialBaudRateGenerator             = 0x24,  // uint16_t,
    SerialTimeout                       = 0x26,  // uint16_t,
    SerialDeviceNumber                  = 0x28,  // uint16_t,
    ErrorEnable                         = 0x2A,  // uint16_t
    ErrorLatch                          = 0x2C,  // uint16_t
    ErrorHard                           = 0x2E,  // uint16_t
    VinCalibration                      = 0x30,  // uint16_t
    PwmFrequency                        = 0x32,  // uint8_t
    CurrentSamplesExponent              = 0x33,  // uint8_t
    HardOvercurrentThreshold            = 0x34,  // uint8_t
    CurrentOffsetCalibration            = 0x35,  // uint16_t
    CurrentScaleCalibration             = 0x37,  // uint16_t
    FBTMethod                           = 0x39,  // uint8_t
    FBTOptions                          = 0x3A,  // uint8_t
    FBTTimingTimeout                    = 0x3B,  // uint16_t
    FBTSamples                          = 0x3D,  // uint8_t
    FBTDividerExponent                  = 0x3E,  // uint8_t
    IntegralDividerExponent             = 0x3F,  // uint8_t
    SoftCurrentRegulationLevelForward   = 0x40,  // uint16_t
    SoftCurrentRegulationLevelReverse   = 0x42,  // uint16_t
    OptionsByte3                        = 0x50,  // uint8_t
    ProportionalMultiplier              = 0x51,  // uint16_t
    ProportionalExponent                = 0x53,  // uint8_t
    IntegralMultiplier                  = 0x54,  // uint16_t
    IntegralExponent                    = 0x56,  // uint8_t
    DerivativeMultiplier                = 0x57,  // uint16_t
    DerivativeExponent                  = 0x59,  // uint8_t
    PIDPeriod                           = 0x5A,  // uint16_t
    IntegralLimit                       = 0x5C,  // uint16_t
    MaxDutyCycleWhileFeedbackOutOfRange = 0x5E,  // uint16_t
    MaxAccelerationForward              = 0x60,  // uint16_t
    MaxAccelerationReverse              = 0x62,  // uint16_t
    MaxDecelerationForward              = 0x64,  // uint16_t
    MaxDecelerationReverse              = 0x66,  // uint16_t
    MaxDutyCycleForward                 = 0x68,  // uint16_t
    MaxDutyCycleReverse                 = 0x6A,  // uint16_t
    EncodedHardCurrentLimitForward      = 0x6C,  // uint16_t
    EncodedHardCurrentLimitReverse      = 0x6E,  // uint16_t
    BrakeDurationForward                = 0x70,  // uint8_t
    BrakeDurationReverse                = 0x71,  // uint8_t
    SoftCurrentLimitForward             = 0x72,  // uint16_t
    SoftCurrentLimitReverse             = 0x74,  // uint16_t
  };

  uint8_t getVar8SingleByte(uint8_t offset)
  {
    return commandR8((uint8_t)JrkG2Command::GetVariable8 | (offset + 1));
  }

  uint16_t getVar16SingleByte(uint8_t offset)
  {
    return commandR16((uint8_t)JrkG2Command::GetVariable16 | (offset + 1));
  }

  uint8_t getVar8(uint8_t offset)
  {
    uint8_t result;
    segmentRead(JrkG2Command::GetVariables, offset, 1, &result);
    return result;
  }

  uint16_t getVar16(uint8_t offset)
  {
    uint8_t buffer[2];
    segmentRead(JrkG2Command::GetVariables, offset, 2, buffer);
    return ((uint16_t)buffer[0] << 0) | ((uint16_t)buffer[1] << 8);
  }

  uint32_t getVar32(uint8_t offset)
  {
    uint8_t buffer[4];
    segmentRead(JrkG2Command::GetVariables, offset, 4, buffer);
    return ((uint32_t)buffer[0] << 0) |
      ((uint32_t)buffer[1] << 8) |
      ((uint32_t)buffer[2] << 16) |
      ((uint32_t)buffer[3] << 24);
  }

  void setRAMSetting8(uint8_t offset, uint8_t val)
  {
    segmentWrite(JrkG2Command::SetRAMSettings, offset, 1, &val);
  }

  void setRAMSetting16(uint8_t offset, uint16_t val)
  {
    uint8_t buffer[2] = {(uint8_t)val, (uint8_t)(val >> 8)};
    segmentWrite(JrkG2Command::SetRAMSettings, offset, 2, buffer);
  }

  void setRAMSetting8x2(uint8_t offset, uint8_t val1, uint8_t val2)
  {
    uint8_t buffer[2] = {val1, val2};
    segmentWrite(JrkG2Command::SetRAMSettings, offset, 2, buffer);
  }

  void setRAMSetting16x2(uint8_t offset, uint16_t val1, uint16_t val2)
  {
    uint8_t buffer[4] = {(uint8_t)val1, (uint8_t)(val1 >> 8),
                         (uint8_t)val2, (uint8_t)(val2 >> 8)};
    segmentWrite(JrkG2Command::SetRAMSettings, offset, 4, buffer);
  }

  // set multiplier and exponent together in one segment write
  // (slightly faster than separate calls to getRAMSetting16() and getRAMSetting8())
  void setPIDCoefficient(uint8_t offset, uint16_t multiplier, uint8_t exponent)
  {
    uint8_t buffer[3] = {(uint8_t)multiplier, (uint8_t)(multiplier >> 8), exponent};
    segmentWrite(JrkG2Command::SetRAMSettings, offset, 3, buffer);
  }

  uint8_t getRAMSetting8(uint8_t offset)
  {
    uint8_t result;
    segmentRead(JrkG2Command::GetRAMSettings, offset, 1, &result);
    return result;
  }

  uint16_t getRAMSetting16(uint8_t offset)
  {
    uint8_t buffer[2];
    segmentRead(JrkG2Command::GetRAMSettings, offset, 2, buffer);
    return ((uint16_t)buffer[0] << 0) | ((uint16_t)buffer[1] << 8);
  }

  // Convenience functions that take care of casting a JrkG2Command to a uint8_t.

  void commandQuick(JrkG2Command cmd)
  {
    commandQuick((uint8_t)cmd);
  }

  void commandW7(JrkG2Command cmd, uint8_t val)
  {
    commandW7((uint8_t)cmd, val);
  }

  void commandWs14(JrkG2Command cmd, int16_t val)
  {
    commandWs14((uint8_t)cmd, val);
  }

  uint8_t commandR8(JrkG2Command cmd)
  {
    return commandR8((uint8_t)cmd);
  }

  uint16_t commandR16(JrkG2Command cmd)
  {
    return commandR16((uint8_t)cmd);
  }

  void segmentRead(JrkG2Command cmd, uint8_t offset,
    uint8_t length, uint8_t * buffer)
  {
    segmentRead((uint8_t)cmd, offset, length, buffer);
  }

  void segmentWrite(JrkG2Command cmd, uint8_t offset,
    uint8_t length, uint8_t * buffer)
  {
    segmentWrite((uint8_t)cmd, offset, length, buffer);
  }

  // Low-level functions implemented by the serial/I2C subclasses.

  virtual void commandQuick(uint8_t cmd) = 0;
  virtual void commandW7(uint8_t cmd, uint8_t val) = 0;
  virtual void commandWs14(uint8_t cmd, int16_t val) = 0;
  virtual uint8_t commandR8(uint8_t cmd) = 0;
  virtual uint16_t commandR16(uint8_t cmd) = 0;
  virtual void segmentRead(uint8_t cmd, uint8_t offset,
    uint8_t length, uint8_t * buffer) = 0;
  virtual void segmentWrite(uint8_t cmd, uint8_t offset,
    uint8_t length, uint8_t * buffer) = 0;
};

class JrkG2Serial : public JrkG2Base
{
public:
  JrkG2Serial(Stream & stream, uint8_t deviceNumber = 255) :
    _stream(&stream),
    _deviceNumber(deviceNumber)
  {
  }

  uint8_t getDeviceNumber() { return _deviceNumber; }

private:
  Stream * const _stream;
  const uint8_t _deviceNumber;

  void commandQuick(uint8_t cmd) { sendCommandHeader(cmd); }
  void commandW7(uint8_t cmd, uint8_t val);
  void commandWs14(uint8_t cmd, int16_t val);
  uint8_t commandR8(uint8_t cmd);
  uint16_t commandR16(uint8_t cmd);
  void segmentRead(uint8_t cmd, uint8_t offset,
    uint8_t length, uint8_t * buffer);
  void segmentWrite(uint8_t cmd, uint8_t offset,
    uint8_t length, uint8_t * buffer);

  void sendCommandHeader(uint8_t cmd);
  void serialW7(uint8_t val) { _stream->write(val & 0x7F); }
};

class JrkG2I2C : public JrkG2Base
{
public:
  JrkG2I2C(uint8_t address = 11) : _address(address & 0x7F)
  {
  }

  // TODO: support Wire1 on Arduino Due, and bit-banging I2C on any board?

  uint8_t getAddress() { return _address; }

private:
  const uint8_t _address;

  void commandQuick(uint8_t cmd);
  void commandW7(uint8_t cmd, uint8_t val);
  void commandWs14(uint8_t cmd, int16_t val);
  uint8_t commandR8(uint8_t cmd);
  uint16_t commandR16(uint8_t cmd);
  void segmentRead(uint8_t cmd, uint8_t offset,
    uint8_t length, uint8_t * buffer);
  void segmentWrite(uint8_t cmd, uint8_t offset,
    uint8_t length, uint8_t * buffer) ;
};