Library for JrkG2. this bases on Arduino Library (https://github.com/pololu/jrk-g2-arduino)

JrkG2.h

Committer:
sgrsn
Date:
2018-08-25
Revision:
1:d611aa1f9f70
Parent:
0:33bfb28b0ffc
Child:
2:e78c0ddcf337

File content as of revision 1:d611aa1f9f70:

#pragma once

#include "mbed.h"

/*example**********************************

#include "mbed.h"
#include "JrkG2.h"

int main()
{
    //on the other or both
    
    //on Serial
    Serial device(p9, p10);
    JrkG2Serial jrk(&device);
    
    //on I2C
    I2C device(p28, p27);
    JrkG2I2C jrk(&device);
    
    while(1)
    {
        wait_ms(1500);
        jrk.setTarget(2500);
        wait_ms(1500);
        jrk.setTarget(1500);
    }
}

***********************************************/

/// This is used to represent a null or missing value for some of the Jrk G2's
/// 16-bit input variables.
const uint16_t JrkG2InputNull = 0xFFFF;

/// This value is returned by getLastError() if the last communication with the
/// device resulted in an unsuccessful read (e.g. timeout or NACK).
const uint8_t JrkG2CommReadError = 50;

/// This enum defines the Jrk's error bits.  See the "Error handling" section of
/// the Jrk G2 user's guide for more information about what these errors mean.
///
/// See JrkG2Base::getErrorFlagsHalting() and JrkG2Base::getErrorFlagsOccurred().
enum 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,
};

/// This enum defines the Jrk G2 command bytes which are used for its serial and
/// I2C interfaces.  These bytes are used by the library and you should not need
/// to use them.
enum 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,
};

/// This enum defines the modes in which the Jrk G2's duty cycle target or duty
/// cycle, normally derived from the output of its PID algorithm, can be
/// overridden with a forced value.
///
/// See JrkG2Base::getForceMode(), JrkG2Base::forceDutyCycleTarget(), and
/// JrkG2Base::forceDutyCycle().
enum JrkG2ForceMode
{
    None            = 0,
    DutyCycleTarget = 1,
    DutyCycle       = 2,
};

/// This enum defines the possible causes of a full microcontroller reset for
/// the Jrk G2.
///
/// See JrkG2Base::getDeviceReset().
enum JrkG2Reset
{
    PowerUp        = 0,
    Brownout       = 1,
    ResetLine      = 2,
    Watchdog       = 4,
    Software       = 8,
    StackOverflow  = 16,
    StackUnderflow = 32,
};

/// This enum defines the Jrk G2's control and feedback pins
enum JrkG2Pin
{
    SCL = 0,
    SDA = 1,
    TX  = 2,
    RX  = 3,
    RC  = 4,
    AUX = 5,
    FBA = 6,
    FBT = 7,
};

/// This enum defines the bits in the Jrk G2's Options Byte 3 register.  You
/// should not need to use this directly.  See JrkG2Base::setResetIntegral(),
/// JrkG2Base::getResetIntegral(), JrkG2Base::setCoastWhenOff(), and
/// JrkG2Base::getCoastWhenOff().
enum JrkG2OptionsByte3
{
    ResetIntegral = 0,
    CoastWhenOff = 1,
};

/// This is a base class used to represent a connection to a Jrk G2.  This class
/// provides high-level functions for sending commands to the Jrk and reading
/// data from it.
///
/// See the subclasses of this class, JrkG2Serial and JrkG2I2C.
class JrkG2Base
{
public:

    JrkG2Base()
    {
        _lastError = 0;
    }
  
    /// Returns 0 if the last communication with the device was successful, and
    /// non-zero if there was an error.
    uint8_t getLastError()
    {
        return _lastError;
    }
    /// Sets the target of the Jrk to a value in the range 0 to 4095.
    ///
    /// The target can represent a target duty cycle, speed, or position depending
    /// on the feedback mode.
    ///
    /// Example usage:
    /// ```
    /// jrkG2.setTarget(3000);
    /// ```
    ///
    /// This functions sends a "Set target" command to the jrk, which clears the
    /// "Awaiting command" error bit and (if the input mode is serial) will set
    /// the jrk's input and target variables.
    ///
    /// See also setTargetLowResRev(), setTargetLowResFwd(), getTarget(),
    /// forceDutyCycleTarget(), forceDutyCycle().
    
    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)SetTarget | (target & 0x1F), target >> 5);
    }
    
    /// Sets the target of the Jrk based on a value in the range 0 to 127.
    ///
    /// If the value is zero, then this command is equivalent to the "Stop motor"
    /// command. Otherwise, the value maps to a 12-bit target less than 2048.
    ///
    /// If the feedback mode is Analog or Tachometer, then the formula is
    /// Target = 2048 - 16 * value.
    ///
    /// If the feedback mode is None (speed control mode), then the formula is
    /// Target = 2048 - (600 / 127) * value.  This means that a value of
    /// 127 will set the duty cycle target to full-speed reverse (-600).
    ///
    /// Example usage:
    /// ```
    /// jrkG2.setTargetLowResRev(100);
    /// ```
    ///
    /// This function sends a "Set target low resolution reverse" command to the
    /// Jrk G2, which clears the "Awaiting command" error bit and (if the input
    /// mode is serial) will set the jrk's input and target variables.
    ///
    /// See also setTargetLowResFwd(), setTarget(), getTarget(), and stopMotor().
    void setTargetLowResRev(uint8_t target)
    {
        if (target > 127) { target = 127; }
        commandW7(SetTargetLowResRev, target);
    }
    
    /// Sets the target of the Jrk based on a value in the range 0 to 127 that
    /// maps to a 12-bit target of 2048 or greater.
    ///
    /// If the feedback mode is Analog or Tachometer, then the formula is
    /// Target = 2048 + 16 * value.
    ///
    /// If the feedback mode is None (speed control mode), then the formula is
    /// Target = 2048 + (600 / 127) * value.  This means that a value of 127 will
    /// set the duty cycle target to full-speed reverse (-600), while a value of
    /// zero will make the motor stop.
    ///
    /// Example usage:
    /// ```
    /// jrkG2.setTargetLowResFwd(100);
    /// ```
    ///
    /// This function sends a "Set target low resolution forward" command to the
    /// Jrk G2, which clears the "Awaiting command" error bit and (if the input
    /// mode is serial) will set the jrk's input and target variables.
    ///
    /// See also setTargetLowResRev(), setTarget(), and getTarget().
    void setTargetLowResFwd(uint8_t target)
    {
        if (target > 127) { target = 127; }
        commandW7(SetTargetLowResFwd, target);
    }
    
    /// Forces the duty cycle target of the Jrk to a value in the range
    /// -600 to +600.
    ///
    /// The Jrk will ignore the results of the usual algorithm for choosing the duty
    /// cycle target, and instead set it to be equal to the target specified by this
    /// command.  The Jrk will set its 'Integral' variable to 0 while in this mode.
    ///
    /// This is useful if the Jrk is configured to use feedback but you want to take
    /// control of the motor for some time, while still respecting errors and motor
    /// limits as usual.
    ///
    /// Example usage:
    /// ```
    /// jrkG2.forceDutyCycleTarget(250);
    /// ```
    ///
    /// This function sends a "Force duty cycle target" command to the Jrk G2, which
    /// clears the "Awaiting command" error bit.
    ///
    /// To get out of this mode, use setTarget(), setTargetLowResFwd(),
    /// setTargetLowResRev(), forceDutyCycle(), or stopMotor().
    ///
    /// See also getForceMode().
    void forceDutyCycleTarget(int16_t dutyCycle)
    {
        if (dutyCycle > 600) { dutyCycle = 600; }
        if (dutyCycle < -600) { dutyCycle = -600; }
        commandWs14(ForceDutyCycleTarget, dutyCycle);
    }

    /// Forces the duty cycle of the Jrk to a value in the range -600 to +600.
    ///
    /// The jrk will ignore the results of the usual algorithm for choosing the
    /// duty cycle, and instead set it to be equal to the value specified by this
    /// command, ignoring all motor limits except the maximum duty cycle
    /// parameters, and ignoring the 'Input invalid', 'Input disconnect', and
    /// 'Feedback disconnect' errors.  This command will have an immediate effect,
    /// regardless of the PID period.  The jrk will set its 'Integral' variable to
    /// 0 while in this mode.
    ///
    /// This is useful if the jrk is configured to use feedback but you want to take
    /// control of the motor for some time, without respecting most motor limits.
    ///
    /// Example usage:
    /// ```
    /// jrkG2.forceDutyCycle(250);
    /// ```
    ///
    /// This function sends a "Force duty cycle" command to the Jrk G2, which
    /// clears the "Awaiting command" error bit.
    ///
    /// To get out of this mode, use setTarget(), setTargetLowResFwd(),
    /// setTargetLowResRev(), forceDutyCycleTarget(), or stopMotor().
    ///
    /// See also getForceMode().
    void forceDutyCycle(int16_t dutyCycle)
    {
        if (dutyCycle > 600) { dutyCycle = 600; }
        if (dutyCycle < -600) { dutyCycle = -600; }
        commandWs14(ForceDutyCycle, dutyCycle);
    }

    /// Turns the motor off.
    ///
    /// This function sends a "Stop motor" command to the Jrk, which sets the
    /// "Awaiting command" error bit.  The Jrk will respect the configured
    /// deceleration limit while decelerating to a duty cycle of 0, unless the
    /// "Awaiting command" error has been configured as a hard error.  Once the duty
    /// cycle reaches zero, the Jrk will either brake or coast.
    ///
    /// Example usage:
    /// ```
    /// jrkG2.stopMotor();
    /// ```
    void stopMotor()
    {
        commandQuick(MotorOff);
    }

    ///@}
    
    ///\name Variable reading commands
    ///@{
    
    /// Gets the input variable.
    ///
    /// The input variable is a raw, unscaled value representing a measurement
    /// taken by the Jrk of the input to the system.  In serial input mode, the
    /// input is equal to the target, which can be set to any value from 0 to 4095
    /// using serial commands.  In analog input mode, the input is a measurement
    /// of the voltage on the SDA pin, where 0 is 0 V and 4092 is a voltage equal
    /// to the Jrk's 5V pin (approximately 4.8 V).  In RC input mode, the input is
    /// the duration of the last RC pulse measured, in units of 2/3 us.
    ///
    /// See the Jrk G2 user's guide for more information about input modes.
    ///
    /// See also getTarget() and setTarget().
    uint16_t getInput()
    {
        return getVar16SingleByte(Input);
    }
    
    /// Gets the target variable.
    ///
    /// In serial input mode, the target is set directly with serial commands.  In
    /// the other input modes, the target is computed by scaling the input, using
    /// the configurable input scaling settings.
    ///
    /// See also setTarget() and getInput().
    uint16_t getTarget()
    {
        return getVar16SingleByte(Target);
    }

    /// Gets the feedback variable.
    ///
    /// The feedback variable is a raw, unscaled feedback value, representing a
    /// measurement taken by the Jrk of the output of the system.  In analog
    /// feedback mode, the feedback is a measurement of the voltage on the FBA
    /// pin, where 0 is 0 V and 4092 is a voltage equal to the Jrk's 5V pin
    /// (approximately 4.8 V).  In frequency feedback mode, the feedback is 2048
    /// plus or minus a measurement of the frequency of pulses on the FBT pin.  In
    /// feedback mode none (open-loop speed control mode), the feedback is always
    /// zero.
    ///
    /// See also getScaledFeedback().
    uint16_t getFeedback()
    {
        return getVar16SingleByte(Feedback);
    }

    /// Gets the scaled feedback variable.
    ///
    /// The scaled feedback is calculated from the feedback using the Jrk's
    /// configurable feedback scaling settings.
    ///
    /// See also getFeedback().
    uint16_t getScaledFeedback()
    {
        return getVar16SingleByte(ScaledFeedback);
    }

    /// Gets the integral variable.
    ///
    /// In general, every PID period, the error (scaled feedback minus target) is
    /// added to the integral (also known as error sum).  There are several
    /// settings to configure the behavior of this variable, and it is used in the
    /// PID calculation.
    int16_t getIntegral()
    {
        return getVar16SingleByte(Integral);
    }

    /// Gets the duty cycle target variable.
    ///
    /// In general, this is the duty cycle that the Jrk is trying to achieve.  A
    /// value of -600 or less means full speed reverse, while a value of 600 or
    /// more means full speed forward.  A value of 0 means stopped (braking or
    /// coasting).  In no feedback mode (open-loop speed control mode), the duty
    /// cycle target is normally the target minus 2048. In other feedback modes,
    /// the duty cycle target is normally the sum of the proportional, integral,
    /// and derivative terms of the PID algorithm.  In any mode, the duty cycle
    /// target can be overridden with forceDutyCycleTarget().
    ///
    /// If an error is stopping the motor, the duty cycle target variable will not
    /// be directly affected, but the duty cycle variable will change/decelerate
    /// to zero.
    ///
    /// See also getDutyCycle(), getLastDutyCycle(), and forceDutyCycleTarget().
    int16_t getDutyCycleTarget()
    {
        return getVar16SingleByte(DutyCycleTarget);
    }

    /// Gets the duty cycle variable.
    ///
    /// The duty cycle variable is the duty cycle at which the jrk is currently
    /// driving the motor.  A value of -600 means full speed reverse, while a
    /// value of 600 means full speed forward.  A value of 0 means stopped
    /// (braking or coasting).  The duty cycle could be different from the duty
    /// cycle target because it normally takes into account the Jrk's configurable
    /// motor limits and errors.  The duty cycle can be overridden with
    /// forceDutyCycle().
    ///
    /// See also getLastDutyCycle(), getDutyCycleTarget(), and forceDutyCycle().
    int16_t getDutyCycle()
    {
        return getVar16SingleByte(DutyCycle);
    }

    /// Gets the most-significant 8 bits of the "Current" variable.
    ///
    /// The Jrk G2 supports this command mainly to be compatible with older Jrk
    /// models.  In new applications, we recommend using getCurrent(), which
    /// provides a higher-resolution measurement.
    uint8_t getCurrentLowRes()
    {
        return getVar8SingleByte(CurrentLowRes);
    }
    
    /// Returns true if the Jrk's most recent PID cycle took more time than the
    /// configured PID period.  This indicates that the Jrk does not have time to
    /// perform all of its tasks at the desired rate.  Most often, this is caused
    /// by the configured number of analog samples for input, feedback, or current
    /// sensing being too high for the configured PID period.
    bool getPIDPeriodExceeded()
    {
        return getVar8SingleByte(PIDPeriodExceeded);
    }

    /// Get the "PID period count" variable, which is the number of PID periods
    /// that have elapsed.  It resets to 0 after reaching 65535.  The duration of
    /// the PID period can be configured.
    uint16_t getPIDPeriodCount()
    {
        return getVar16SingleByte(PIDPeriodCount);
    }
    
    /// Gets the errors that are currently stopping the motor and clears any
    /// latched errors that are enabled.  Calling this function is equivalent to
    /// reading the "Currently stopping motor?" column in the Errors tab of the
    /// configuration utility, and then clicking the "Clear Errors" button.
    ///
    /// Each bit in the returned register represents a different error.  The bits
    /// are defined in the ::JrkG2Error enum.
    ///
    /// Example usage:
    /// ```
    /// uint16_t errors = jrk.getErrorFlagsHalting();
    /// if (errors & (1 << (uint8_t)JrkG2Error::NoPower))
    /// {
    ///   // handle loss of power
    /// }
    /// ```
    ///
    /// It is possible to read this variable without clearing the bits in it using
    /// a getVariables().
    ///
    /// See also getErrorFlagsOccurred().
    uint16_t getErrorFlagsHalting()
    {
        return getVar16SingleByte(ErrorFlagsHalting);
    }

    /// Gets the errors that have occurred since the last time this function was
    /// called.  Unlike getErrorFlagsHalting(), calling this function has no
    /// effect on the motor.
    ///
    /// Note that the Jrk G2 Control Center constantly clears the bits in this
    /// register, so if you are running the Jrk G2 Control Center then you will
    /// not be able to reliably detect errors with this function.
    ///
    /// Each bit in the returned register represents a different error.  The bits
    /// are defined in the ::JrkG2Error enum.
    ///
    /// Example usage:
    /// ```
    /// uint32_t errors = jrk.getErrorsOccurred();
    /// if (errors & (1 << (uint8_t)JrkG2Error::MotorDriver))
    /// {
    ///   // handle a motor driver error
    /// }
    /// ```
    ///
    /// It is possible to read this variable without clearing the bits in it using
    /// getVariables().
    ///
    /// See also getErrorFlagsHalting().
    uint16_t getErrorFlagsOccurred()
    {
        return getVar16SingleByte(ErrorFlagsOccurred);
    }

    /// Returns an indication of whether the Jrk's duty cycle target or duty cycle
    /// are being overridden with a forced value.
    ///
    /// Example usage:
    /// ```
    /// if (jrk.getForceMode() == JrkG2ForceMode::DutyCycleTarget)
    /// {
    ///   // The duty cycle target is being overridden with a forced value.
    /// }
    /// ```
    ///
    /// See also forceDutyCycleTarget() and forceDutyCycle().
    JrkG2ForceMode getForceMode()
    {
        return (JrkG2ForceMode)(getVar8SingleByte(FlagByte1) & 0x03);
    }
    
    /// Gets the measurement of the VIN voltage, in millivolts.
    ///
    /// Example usage:
    /// ```
    /// uint16_t vin = jrk.getVinVoltage();
    /// ```
    uint16_t getVinVoltage()
    {
        return getVar16SingleByte(VinVoltage);
    }

    /// Gets the Jrk's measurement of the current running through the motor, in
    /// milliamps.
    uint16_t getCurrent()
    {
        return getVar16SingleByte(Current);
    }
    
    /// Gets the cause of the Jrk's last full microcontroller reset.
    ///
    /// Example usage:
    /// ```
    /// if (jrk.getDeviceReset() == JrkG2Reset::Brownout)
    /// {
    ///   // There was a brownout reset; the power supply could not keep up.
    /// }
    /// ```
    JrkG2Reset getDeviceReset()
    {
        return (JrkG2Reset)getVar8(DeviceReset);
    }

    /// Gets the time since the last full reset of the Jrk's microcontroller, in
    /// milliseconds.
    ///
    /// Example usage:
    /// ```
    /// uint32_t upTime = jrk.getUpTime();
    /// ```
    uint32_t getUpTime()
    {
        return getVar32(UpTime);
    }
    
    /// Gets the raw RC pulse width measured on the Jrk's RC input, in units of
    /// twelfths of a microsecond.
    ///
    /// Returns 0 if the RC input is missing or invalid.
    ///
    /// Example usage:
    /// ```
    /// uint16_t pulseWidth = jrk.getRCPulseWidth();
    /// if (pulseWidth != 0 && pulseWidth < 18000)
    /// {
    ///   // Input is valid and pulse width is less than 1500 microseconds.
    /// }
    /// ```
    uint16_t getRCPulseWidth()
    {
        return getVar16(RCPulseWidth);
    }

    /// Gets the raw pulse rate or pulse width measured on the Jrk's FBT
    /// (tachometer feedback) pin.
    ///
    /// In pulse counting mode, this will be the number of pulses on the FBT pin
    /// seen in the last N PID periods, where N is the "Pulse samples" setting.
    ///
    /// In pulse timing mode, this will be a measurement of the width of pulses on
    /// the FBT pin.  This measurement is affected by several configurable
    /// settings.
    ///
    /// Example usage:
    /// ```
    /// uint16_t fbtReading = jrk.getFBTReading();
    /// ```
    uint16_t getFBTReading()
    {
        return getVar16(FBTReading);
    }

    /// Gets the analog reading from the specified pin.
    ///
    /// The reading is left-justified, so 0xFFFE represents a voltage equal to the
    /// Jrk's 5V pin (approximately 4.8 V).
    ///
    /// Returns JrkG2InputNull if the analog reading is disabled or not ready or
    /// the pin is invalid.
    ///
    /// Example usage:
    /// ```
    /// uint16_t reading = getAnalogReading(JrkG2Pin::SDA);
    /// if (reading != JrkG2InputNull && reading < 32768)
    /// {
    ///   // The reading is less than about 2.4 V.
    /// }
    /// ```
    uint16_t getAnalogReading(JrkG2Pin pin)
    {
        switch (pin)
        {
            case SDA:
                return getVar16(AnalogReadingSDA);
            case FBA:
                return getVar16(AnalogReadingFBA);
            default:
                return JrkG2InputNull;
        }
    }
    
    /// Gets a digital reading from the specified pin.
    ///
    /// A return value of 0 means low while 1 means high.  In most cases, pins
    /// configured as analog inputs cannot be read as digital inputs, so their
    /// values will be 0.  See getAnalogReading() for those pins.
    ///
    /// Example usage:
    /// ```
    /// if (jrk.getDigitalReading(JrkG2Pin::RC))
    /// {
    ///   // Something is driving the RC pin high.
    /// }
    /// ```
    bool getDigitalReading(JrkG2Pin pin)
    {
        uint8_t readings = getVar8(DigitalReadings);
        return (readings >> (uint8_t)pin) & 1;
    }

    /// Gets the Jrk's raw measurement of the current running through the motor.
    ///
    /// This is an analog voltage reading from the Jrk's current sense
    /// pin.  The units of the reading depend on what hard current limit is being
    /// used (getEncodedHardCurrentLimit()).
    ///
    /// See also getCurrent().
    uint16_t getRawCurrent()
    {
        return getVar16(RawCurrent);
    }
    
    /// Gets the encoded value representing the hardware current limit the jrk is
    /// currently using.
    ///
    /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21.
    /// The Jrk G2 21v3 does not have a configurable hard current limit.
    ///
    /// See also setEncodedHardCurrentLimit(), getCurrent().
    uint16_t getEncodedHardCurrentLimit()
    {
        return getVar16(EncodedHardCurrentLimit);
    }

    /// Gets the duty cycle the Jrk drove the motor with in the last PID period.
    ///
    /// This can be useful for converting the getRawCurrent() reading into
    /// milliamps.
    ///
    /// See also getDutyCycle(), getDutyCycleTarget(), and getCurrent().
    int16_t getLastDutyCycle()
    {
        return getVar16(LastDutyCycle);
    }
    
    /// Gets the number of consecutive PID periods during which current chopping
    /// due to the hard current limit has been active.
    ///
    /// See also getCurrentChoppingOccurrenceCount().
    uint8_t getCurrentChoppingConsecutiveCount()
    {
        return getVar8(CurrentChoppingConsecutiveCount);
    }

    /// Gets and clears the "Current chopping occurrence count" variable, which is
    /// the number of PID periods during which current chopping due to the hard
    /// current limit has been active, since the last time the variable was
    /// cleared.
    ///
    /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21.
    /// The Jrk G2 21v3 cannot sense when current chopping occurs so this command
    /// will always return 0.
    ///
    /// See also getCurrentChoppingConsecutiveCount().
    uint8_t getCurrentChoppingOccurrenceCount()
    {
        return commandR8(GetCurrentChoppingOccurrenceCount);
    }
    ///@}
    
    ///\name RAM settings commands
    ///@{
    
    /// Sets or clears the "Reset integral" setting in the Jrk's RAM settings.
    ///
    /// If this setting is set to true, the PID algorithm will reset the integral
    /// variable (also known as error sum) when the absolute value of the
    /// proportional term exceeds 600.
    ///
    /// When enabled, this can help limit integral wind-up, or the uncontrolled
    /// growth of the integral when the feedback system is temporarily unable to
    /// keep the error small. This might happen, for example, when the target is
    /// changing quickly.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getResetIntegral().
    void setResetIntegral(bool reset)
    {
        uint8_t tmp = getRAMSetting8(OptionsByte3);
        if (getLastError()) { return; }
        if (reset)
        {
            tmp |= 1 << (uint8_t)ResetIntegral;
        }
        else
        {
            tmp &= ~(1 << (uint8_t)ResetIntegral);
        }
        setRAMSetting8(OptionsByte3, tmp);
    }
    
    /// Gets the "Reset integral" setting from the Jrk's RAM settings.
    ///
    /// See also setResetIntegral().
    bool getResetIntegral()
    {
        return getRAMSetting8(OptionsByte3) >>
        (uint8_t)ResetIntegral & 1;
    }

    /// Sets or clears the "Coast when off" setting in the Jrk's RAM settings.
    ///
    /// By default, the Jrk drives both motor outputs low when the motor is
    /// stopped (duty cycle is zero), causing it to brake.  If enabled, this
    /// setting causes it to instead tri-state both outputs, making the motor
    /// coast.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getCoastWhenOff().
    void setCoastWhenOff(bool coast)
    {
        uint8_t tmp = getRAMSetting8(OptionsByte3);
        if (getLastError()) { return; }
        if (coast)
        {
            tmp |= 1 << (uint8_t)CoastWhenOff;
        }
        else
        {
            tmp &= ~(1 << (uint8_t)CoastWhenOff);
        }
        setRAMSetting8(OptionsByte3, tmp);
    }

    /// Gets the "Coast when off" setting from the Jrk's RAM settings.
    ///
    /// See also setCoastWhenOff().
    bool getCoastWhenOff()
    {
        return getRAMSetting8(OptionsByte3) >>
        (uint8_t)CoastWhenOff & 1;
    }
    
    /// Sets the proportional coefficient in the Jrk's RAM settings.
    ///
    /// This coefficient is used in the Jrk's PID algorithm.  The coefficient
    /// takes the form:
    ///
    /// multiplier / (2 ^ exponent)
    ///
    /// The multiplier can range from 0 to 1023, and the exponent can range
    /// from 0 to 18.
    ///
    /// Example usage:
    /// ```
    /// // Set the proportional coefficient to 1.125 (9/(2^3)).
    /// jrk.setProportionalCoefficient(9, 3);
    /// ```
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getProportionalMultiplier() and getProportionalExponent(), as
    /// well as setIntegralCoefficient() and setDerivativeCoefficient().
    void setProportionalCoefficient(uint16_t multiplier, uint8_t exponent)
    {
        setPIDCoefficient(ProportionalMultiplier, multiplier, exponent);
    }

    /// Gets the multiplier part of the proportional coefficient from the Jrk's
    /// RAM settings.
    ///
    /// See also getProportionalExponent() and setProportionalCoefficient().
    uint16_t getProportionalMultiplier()
    {
        return getRAMSetting16(ProportionalMultiplier);
    }
    
    /// Gets the exponent part of the proportional coefficient from the Jrk's RAM
    /// settings.
    ///
    /// See also getProportionalMultiplier() and setProportionalCoefficient().
    uint8_t getProportionalExponent()
    {
        return getRAMSetting8(ProportionalExponent);
    }

    /// Sets the integral coefficient in the Jrk's RAM settings.
    ///
    /// This coefficient is used in the Jrk's PID algorithm.  The coefficient
    /// takes the form:
    ///
    /// multiplier / (2 ^ exponent)
    ///
    /// The multiplier can range from 0 to 1023, and the exponent can range
    /// from 0 to 18.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getIntegralMultiplier() and getIntegralExponent(), as
    /// well as setProportionalCoefficient() and setDerivativeCoefficient().
    void setIntegralCoefficient(uint16_t multiplier, uint8_t exponent)
    {
        setPIDCoefficient(IntegralMultiplier, multiplier, exponent);
    }

    /// Gets the multiplier part of the integral coefficient from the Jrk's
    /// RAM settings.
    ///
    /// See also getIntegralExponent() and setIntegralCoefficient().
    uint16_t getIntegralMultiplier()
    {
        return getRAMSetting16(IntegralMultiplier);
    }
    
    /// Gets the exponent part of the integral coefficient from the Jrk's
    /// RAM settings.
    ///
    /// See also getIntegralMultiplier() and setIntegralCoefficient().
    uint8_t getIntegralExponent()
    {
        return getRAMSetting8(IntegralExponent);
    }

    /// Sets the derivative coefficient in the Jrk's RAM settings.
    ///
    /// This coefficient is used in the Jrk's PID algorithm.  The coefficient
    /// takes the form:
    ///
    /// multiplier / (2 ^ exponent)
    ///
    /// The multiplier can range from 0 to 1023, and the exponent can range
    /// from 0 to 18.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getDerivativeMultiplier() and getDerivativeExponent(), as
    /// well as setProportionalCoefficient() and setIntegralCoefficient().
    void setDerivativeCoefficient(uint16_t multiplier, uint8_t exponent)
    {
        setPIDCoefficient(DerivativeMultiplier, multiplier, exponent);
    }

    /// Gets the multiplier part of the derivative coefficient from the
    /// Jrk's RAM settings.
    ///
    /// See also getDerivativeExponent() and setDerivativeCoefficient().
    uint16_t getDerivativeMultiplier()
    {
        return getRAMSetting16(DerivativeMultiplier);
    }
    
    /// Gets the exponent part of the derivative coefficient from the
    /// Jrk's RAM settings.
    ///
    /// See also getDerivativeMultiplier() and setDerivativeCoefficient().
    uint8_t getDerivativeExponent()
    {
        return getRAMSetting8(DerivativeExponent);
    }
    
    /// Sets the PID period in the Jrk's RAM settings.
    ///
    /// This is the rate at which the Jrk runs through all of its calculations, in
    /// milliseconds.  Note that a higher PID period will result in a more slowly
    /// changing integral and a higher derivative, so the two corresponding PID
    /// coefficients might need to be adjusted whenever the PID period is changed.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getPIDPeriod().
    void setPIDPeriod(uint16_t period)
    {
        setRAMSetting16(PIDPeriod, period);
    }
    
    /// Gets the PID period from the Jrk's RAM settings, in milliseconds.
    ///
    /// See also setPIDPeriod().
    uint16_t getPIDPeriod()
    {
        return getRAMSetting16(PIDPeriod);
    }

    /// Sets the integral limit in the Jrk's RAM settings.
    ///
    /// The PID algorithm prevents the absolute value of the integral variable
    /// (also known as error sum) from exceeding this limit.  This can help limit
    /// integral wind-up.  The limit can range from 0 to 32767.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getIntegralLimit().
    void setIntegralLimit(uint16_t limit)
    {
        setRAMSetting16(IntegralLimit, limit);
    }

    /// Gets the integral limit from the Jrk's RAM settings.
    ///
    /// See also setIntegralLimit().
    uint16_t getIntegralLimit()
    {
        return getRAMSetting16(IntegralLimit);
    }
    
    /// Sets the maximum duty cycle while feedback is out of range in the Jrk's
    /// RAM settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getMaxDutyCycleWhileFeedbackOutOfRange().
    void setMaxDutyCycleWhileFeedbackOutOfRange(uint16_t duty)
    {
        setRAMSetting16(MaxDutyCycleWhileFeedbackOutOfRange, duty);
    }

    /// Gets the maximum duty cycle while feedback is out of range from the Jrk's RAM
    /// settings.
    ///
    /// See also setMaxDutyCycleWhileFeedbackOutOfRange().
    uint16_t getMaxDutyCycleWhileFeedbackOutOfRange()
    {
        return getRAMSetting16(MaxDutyCycleWhileFeedbackOutOfRange);
    }

    /// Sets the maximum acceleration in the forward direction in the
    /// Jrk's RAM settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getMaxAccelerationForward(), setMaxAccelerationReverse(),
    /// setMaxAcceleration(), and setMaxDecelerationForward().
    void setMaxAccelerationForward(uint16_t accel)
    {
        setRAMSetting16(MaxAccelerationForward, accel);
    }

    /// Gets the maximum acceleration in the forward direction from the
    /// Jrk's RAM settings.
    ///
    /// See also setMaxAccelerationForward().
    uint16_t getMaxAccelerationForward()
    {
        return getRAMSetting16(MaxAccelerationForward);
    }
    
    /// Sets the maximum acceleration in the reverse direction in the
    /// Jrk's RAM settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getMaxAccelerationReverse(), setMaxAccelerationForward(),
    /// setMaxAcceleration(), and setMaxDecelerationReverse().
    void setMaxAccelerationReverse(uint16_t accel)
    {
        setRAMSetting16(MaxAccelerationReverse, accel);
    }

    /// Gets the maximum acceleration in the reverse direction from the
    /// Jrk's RAM settings.
    ///
    /// See also setMaxAccelerationReverse().
    uint16_t getMaxAccelerationReverse()
    {
        return getRAMSetting16(MaxAccelerationReverse);
    }
    
    /// Sets the maximum acceleration in both directions in the
    /// Jrk's RAM settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also setMaxAccelerationForward(), setMaxAccelerationReverse(),
    /// setMaxDeceleration().
    void setMaxAcceleration(uint16_t accel)
    {
        setRAMSetting16x2(MaxAccelerationForward, accel, accel);
    }

    /// Sets the maximum deceleration in the forward direction in the Jrk's RAM
    /// settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getMaxDecelerationForward(), setMaxDecelerationReverse(),
    /// setMaxDeceleration(), and setMaxAccelerationForward().
    void setMaxDecelerationForward(uint16_t decel)
    {
        setRAMSetting16(MaxDecelerationForward, decel);
    }
    
    /// Gets the maximum deceleration in the forward direction from the Jrk's RAM
    /// settings.
    ///
    /// See also setMaxDecelerationForward().
    uint16_t getMaxDecelerationForward()
    {
        return getRAMSetting16(MaxDecelerationForward);
    }

    /// Sets the maximum deceleration in the reverse direction in the
    /// Jrk's RAM settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getMaxDecelerationReverse(), setMaxDecelerationForward(),
    /// setMaxDeceleration(), and setMaxAccelerationReverse().
    void setMaxDecelerationReverse(uint16_t decel)
    {
        setRAMSetting16(MaxDecelerationReverse, decel);
    }
    
    /// Gets the maximum deceleration in the reverse direction from the Jrk's RAM
    /// settings.
    ///
    /// See also setMaxDecelerationReverse().
    uint16_t getMaxDecelerationReverse()
    {
        return getRAMSetting16(MaxDecelerationReverse);
    }

    /// Sets the maximum deceleration in both directions in the
    /// Jrk's RAM settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also setMaxDecelerationForward(), setMaxDecelerationReverse(),
    /// setMaxAcceleration().
    void setMaxDeceleration(uint16_t decel)
    {
        setRAMSetting16x2(MaxDecelerationForward, decel, decel);
    }
    
    /// Sets the maximum duty cycle in the forward direction in the
    /// Jrk's RAM settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getMaxDutyCycleForward(), setMaxDutyCycleReverse().
    void setMaxDutyCycleForward(uint16_t duty)
    {
        setRAMSetting16(MaxDutyCycleForward, duty);
    }

    /// Gets the maximum duty cycle in the forward direction from the Jrk's RAM
    /// settings.
    ///
    /// See also setMaxDutyCycleForward().
    uint16_t getMaxDutyCycleForward()
    {
        return getRAMSetting16(MaxDutyCycleForward);
    }
    
    /// Sets the maximum duty cycle in the reverse direction in the
    /// Jrk's RAM settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getMaxDutyCycleReverse(), setMaxDutyCycleForard().
    void setMaxDutyCycleReverse(uint16_t duty)
    {
        setRAMSetting16(MaxDutyCycleReverse, duty);
    }
    
    /// Gets the maximum duty cycle in the reverse direction from the
    /// Jrk's RAM settings.
    ///
    /// See also setMaxDutyCycleReverse().
    uint16_t getMaxDutyCycleReverse()
    {
        return getRAMSetting16(MaxDutyCycleReverse);
    }

    /// Sets the maximum duty cycle for both directions in the
    /// Jrk's RAM settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also setMaxDutyCycleForward(), setMaxDutyCycleReverse().
    void setMaxDutyCycle(uint16_t duty)
    {
        setRAMSetting16x2(MaxDutyCycleForward, duty, duty);
    }
    
    /// Sets the encoded hard current limit for driving in the forward direction
    /// in the Jrk's RAM settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21.
    /// The Jrk G2 21v3 does not have a configurable hard current limit.
    ///
    /// See also getEncodedHardCurrentLimitForward() and
    /// setEncodedHardCurrentLimitReverse().
    void setEncodedHardCurrentLimitForward(uint16_t encoded_limit)
    {
        setRAMSetting16(EncodedHardCurrentLimitForward,
        encoded_limit);
    }

    /// Gets the encoded hard current limit for driving in the forward direction
    /// from the Jrk's RAM settings.
    ///
    /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21.
    /// The Jrk G2 21v3 does not have a configurable hard current limit.
    ///
    /// See also setEncodedHardCurrentLimitForward().
    uint16_t getEncodedHardCurrentLimitForward()
    {
        return getRAMSetting16(EncodedHardCurrentLimitForward);
    }
    
    /// Sets the encoded hard current limit for driving in the reverse direction
    /// in the Jrk's RAM settings
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21.
    /// The Jrk G2 21v3 does not have a configurable hard current limit.
    ///
    /// See also getEncodedHardCurrentLimitReverse() and
    /// setEncodedHardCurrentLimitForward().
    void setEncodedHardCurrentLimitReverse(uint16_t encoded_limit)
    {
        setRAMSetting16(EncodedHardCurrentLimitReverse, encoded_limit);
    }

    /// Gets the encoded hard current limit for driving in the reverse direction
    /// from the Jrk's RAM settings.
    ///
    /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21.
    /// The Jrk G2 21v3 does not have a configurable hard current limit.
    ///
    /// See also setEncodedHardCurrentLimitReverse().
    uint16_t getEncodedHardCurrentLimitReverse()
    {
        return getRAMSetting16(EncodedHardCurrentLimitReverse);
    }
    
    /// Sets the encoded hard current limit for both directions in the Jrk's RAM
    /// settings.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21.
    /// The Jrk G2 21v3 does not have a configurable hard current limit.
    ///
    /// See also setEncodedHardCurrentLimitForward(),
    /// setEncodedHardCurrentLimitReverse(), getEncodedHardCurrentLimit(), and
    /// setSoftCurrentLimit().
    void setEncodedHardCurrentLimit(uint16_t encoded_limit)
    {
        setRAMSetting16x2(EncodedHardCurrentLimitForward,
        encoded_limit, encoded_limit);
    }

    /// Sets the brake duration when switching from forward to reverse in the
    /// Jrk's RAM settings, in units of 5 ms.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getBrakeDurationForward() and setBrakeDurationReverse().
    void setBrakeDurationForward(uint8_t duration)
    {
        setRAMSetting8(BrakeDurationForward, duration);
    }
    
    /// Gets the brake duration when switching from forward to reverse from the
    /// Jrk's RAM settings, in units of 5 ms.
    ///
    /// See also setBrakeDurationForward().
    uint8_t getBrakeDurationForward()
    {
        return getRAMSetting8(BrakeDurationForward);
    }
    
    /// Sets the brake duration when switching from reverse to forward in the
    /// Jrk's RAM settings, in units of 5 ms.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getBrakeDurationReverse() and setBrakeDurationForward().
    void setBrakeDurationReverse(uint8_t duration)
    {
        setRAMSetting8(BrakeDurationReverse, duration);
    }

    /// Gets the brake duration when switching from reverse to forward from the
    /// Jrk's RAM settings, in units of 5 ms.
    ///
    /// See also setBrakeDurationReverse().
    uint8_t getBrakeDurationReverse()
    {
        return getRAMSetting8(BrakeDurationReverse);
    }
    
    /// Sets the brake duration for both directions in the Jrk's RAM settings, in
    /// units of 5 ms.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also setBrakeDurationForward(), setBrakeDurationReverse().
    void setBrakeDuration(uint8_t duration)
    {
        setRAMSetting8x2(BrakeDurationForward, duration, duration);
    }

    /// Sets the soft current limit when driving in the forward direction in the
    /// Jrk's RAM settings, in units of mA.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getSoftCurrentLimitForward() and setSoftCurrentLimitReverse().
    void setSoftCurrentLimitForward(uint16_t current)
    {
        setRAMSetting16(SoftCurrentLimitForward, current);
    }
    
    /// Gets the soft current limit when driving in the forward direction from the
    /// Jrk's RAM settings, in units of mA.
    ///
    /// See also setSoftCurrentLimitForward().
    uint16_t getSoftCurrentLimitForward()
    {
        return getRAMSetting16(SoftCurrentLimitForward);
    }
    
    /// Sets the soft current limit when driving in the reverse direction in the
    /// Jrk's RAM settings, in units of mA.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also getSoftCurrentLimitReverse() and setSoftCurrentLimitForward().
    void setSoftCurrentLimitReverse(uint16_t current)
    {
        setRAMSetting16(SoftCurrentLimitReverse, current);
    }
    
    /// Gets the soft current limit when driving in the reverse direction from the
    /// Jrk's RAM settings, in units of mA.
    ///
    /// See also setSoftCurrentLimitReverse().
    uint16_t getSoftCurrentLimitReverse()
    {
        return getRAMSetting16(SoftCurrentLimitReverse);
    }
    
    /// Sets the soft current limit for driving in both directions in the Jrk's
    /// RAM settings, in units of mA.
    ///
    /// You would normally configure this setting ahead of time using the Jrk G2
    /// Configuration Utility, but this function allows you to change it
    /// temporarily on the fly.
    ///
    /// See also setSoftCurrentLimitForward() and setSoftCurrentLimitReverse(),
    /// setEncodedHardCurrentLimit().
    void setSoftCurrentLimit(uint16_t current)
    {
        setRAMSetting16x2(SoftCurrentLimitForward, current, current);
    }
    
    // TODO: add functions to get and set the soft current regulation level
    
    ///@}
    
    ///\name Low-level settings and variables commands
    ///@{
    
    /// Gets a contiguous block of settings from the Jrk G2's EEPROM.
    ///
    /// The maximum length that can be fetched is 15 bytes.
    ///
    /// Example usage:
    /// ```
    /// // Get the Jrk's serial device number.
    /// uint8_t deviceNumber;
    /// jrk.getEEPROMSettings(0x28, 1, &deviceNumber);
    /// ```
    ///
    /// For information on how the settings are encoded,
    /// see the Jrk G2 user's guide.
    void getEEPROMSettings(uint8_t offset, uint8_t length, uint8_t * buffer)
    {
        segmentRead(GetEEPROMSettings, offset, length, buffer);
    }
    
    /// Gets a contiguous block of settings from the Jrk G2's RAM.
    ///
    /// The maximum length that can be fetched is 15 bytes.
    ///
    /// Example usage:
    /// ```
    /// // Get the Jrk's feedback maximum setting.
    /// uint8_t buffer[2];
    /// jrk.getRAMSettings(0x1F, 2, buffer);
    /// uint16_t feedbackMaximum = buffer[0] + (buffer[1] << 8);
    /// ```
    ///
    /// Note that this library has several functions for reading and writing
    /// specific RAM settings, and they are easier to use than this function.
    ///
    /// For information on how the settings are encoded,
    /// see the Jrk G2 user's guide.
    void getRAMSettings(uint8_t offset, uint8_t length, uint8_t * buffer)
    {
        segmentRead(GetRAMSettings, offset, length, buffer);
    }

    /// Sets a contiguous block of settings in the Jrk G2's RAM.
    ///
    /// The maximum length that can be written in a single command
    /// is 7 bytes over Serial, 13 bytes over I2C.
    ///
    /// Example usage:
    /// ```
    /// // Set the Jrk's feedback maximum setting.
    /// uint16_t feedbackMaximum = 1234;
    /// uint8_t buffer[2];
    /// buffer[0] = feedbackMaximum & 0xFF;
    /// buffer[1] = feedbackMaximum >> 8 & 0xFF;
    /// jrk.setRAMSettings(0x1F, 2, buffer);
    /// ```
    ///
    /// Note that this library has several functions for reading and writing
    /// specific RAM settings, and they are easier to use than this function.
    ///
    /// For information on how the settings are encoded,
    /// see the Jrk G2 user's guide.
    void setRAMSettings(uint8_t offset, uint8_t length, uint8_t * buffer)
    {
        segmentWrite(SetRAMSettings, offset, length, buffer);
    }

    /// Gets a contiguous block of variables from the Jrk G2.
    ///
    /// Note that this library has convenient functions for reading every variable
    /// provided by the Jrk.  The main reason to use this function is if you want
    /// to read multiple variables at once for extra efficiency or to ensure that
    /// the variables are in a consistent state.
    ///
    /// The maximum length that can be fetched is 15 bytes.
    ///
    /// Example usage:
    /// ```
    /// // Get the Jrk's last device reset and its up time.
    /// uint8_t buffer[5];
    /// jrk.getVariables(0x1F, 5, buffer);
    /// ```
    ///
    /// For information on how the variables are encoded,
    /// see the Jrk G2 user's guide.
    void getVariables(uint8_t offset, uint8_t length, uint8_t * buffer)
    {
        segmentRead(GetVariables, offset, length, buffer);
    }

    ///@}

protected:
    /// Zero if the last communication with the device was successful, non-zero
    /// otherwise.
    uint8_t _lastError;

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)GetVariable8 | (offset + 1));
    }
    
    uint16_t getVar16SingleByte(uint8_t offset)
    {
        return commandR16((uint8_t)GetVariable16 | (offset + 1));
    }
    
    uint8_t getVar8(uint8_t offset)
    {
        uint8_t result;
        segmentRead(GetVariables, offset, 1, &result);
        return result;
    }
    
    uint16_t getVar16(uint8_t offset)
    {
        uint8_t buffer[2];
        segmentRead(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(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(SetRAMSettings, offset, 1, &val);
    }
    
    void setRAMSetting16(uint8_t offset, uint16_t val)
    {
        uint8_t buffer[2] = {(uint8_t)val, (uint8_t)(val >> 8)};
        segmentWrite(SetRAMSettings, offset, 2, buffer);
    }
    
    void setRAMSetting8x2(uint8_t offset, uint8_t val1, uint8_t val2)
    {
        uint8_t buffer[2] = {val1, val2};
        segmentWrite(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(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(SetRAMSettings, offset, 3, buffer);
    }
    
    uint8_t getRAMSetting8(uint8_t offset)
    {
        uint8_t result;
        segmentRead(GetRAMSettings, offset, 1, &result);
        return result;
    }
    
    uint16_t getRAMSetting16(uint8_t offset)
    {
        uint8_t buffer[2];
        segmentRead(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;
};

/// Represents a serial connection to a Jrk G2.
///
/// For the high-level commands you can use on this object, see JrkG2Base.
class JrkG2Serial : public JrkG2Base //public Stream
{
public:
    JrkG2Serial(Serial *stream, uint8_t deviceNumber = 255) :
    _deviceNumber(deviceNumber)
    {
        _stream = stream;
    }

    /// Gets the serial device number this object is using.
    uint8_t getDeviceNumber() { return _deviceNumber; }

private:
    Serial *_stream;
    const uint8_t _deviceNumber;
    
    virtual void commandQuick(uint8_t cmd) { sendCommandHeader(cmd); }
    virtual void commandW7(uint8_t cmd, uint8_t val);
    virtual void commandWs14(uint8_t cmd, int16_t val);
    virtual uint8_t commandR8(uint8_t cmd);
    virtual uint16_t commandR16(uint8_t cmd);
    virtual void segmentRead(uint8_t cmd, uint8_t offset,
    uint8_t length, uint8_t * buffer);
    virtual 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); }
    void serialW7(uint8_t val) { _stream->putc(val & 0x7F); }
};

/// Represents an I2C connection to a Jrk G2.
///
/// For the high-level commands you can use on this object, see JrkG2Base.
class JrkG2I2C : public JrkG2Base
{
public:
  JrkG2I2C(I2C *i2c, uint8_t address = 11) : _address((address & 0x7F) << 1)
  {
      _i2c = i2c;
  }

  /// Gets the I2C address this object is using.
  uint8_t getAddress() { return _address; }

private:
    I2C *_i2c;
    const uint8_t _address;
    
    virtual void commandQuick(uint8_t cmd);
    virtual void commandW7(uint8_t cmd, uint8_t val);
    virtual void commandWs14(uint8_t cmd, int16_t val);
    virtual uint8_t commandR8(uint8_t cmd);
    virtual uint16_t commandR16(uint8_t cmd);
    virtual void segmentRead(uint8_t cmd, uint8_t offset,
        uint8_t length, uint8_t * buffer);
    virtual void segmentWrite(uint8_t cmd, uint8_t offset,
        uint8_t length, uint8_t * buffer) ;
};