Library for JrkG2. this bases on Arduino Library (https://github.com/pololu/jrk-g2-arduino)
JrkG2.h@2:e78c0ddcf337, 2018-08-26 (annotated)
- Committer:
- sgrsn
- Date:
- Sun Aug 26 08:42:11 2018 +0000
- Revision:
- 2:e78c0ddcf337
- Parent:
- 1:d611aa1f9f70
Use AsyncSerial for Serial require.
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
sgrsn | 0:33bfb28b0ffc | 1 | #pragma once |
sgrsn | 0:33bfb28b0ffc | 2 | |
sgrsn | 0:33bfb28b0ffc | 3 | #include "mbed.h" |
sgrsn | 2:e78c0ddcf337 | 4 | #include "AsyncSerial.hpp" |
sgrsn | 0:33bfb28b0ffc | 5 | |
sgrsn | 0:33bfb28b0ffc | 6 | /*example********************************** |
sgrsn | 0:33bfb28b0ffc | 7 | |
sgrsn | 0:33bfb28b0ffc | 8 | #include "mbed.h" |
sgrsn | 0:33bfb28b0ffc | 9 | #include "JrkG2.h" |
sgrsn | 0:33bfb28b0ffc | 10 | |
sgrsn | 0:33bfb28b0ffc | 11 | int main() |
sgrsn | 0:33bfb28b0ffc | 12 | { |
sgrsn | 0:33bfb28b0ffc | 13 | //on the other or both |
sgrsn | 0:33bfb28b0ffc | 14 | |
sgrsn | 0:33bfb28b0ffc | 15 | //on Serial |
sgrsn | 2:e78c0ddcf337 | 16 | AsyncSerial device(p9, p10); |
sgrsn | 0:33bfb28b0ffc | 17 | JrkG2Serial jrk(&device); |
sgrsn | 0:33bfb28b0ffc | 18 | |
sgrsn | 0:33bfb28b0ffc | 19 | //on I2C |
sgrsn | 0:33bfb28b0ffc | 20 | I2C device(p28, p27); |
sgrsn | 0:33bfb28b0ffc | 21 | JrkG2I2C jrk(&device); |
sgrsn | 0:33bfb28b0ffc | 22 | |
sgrsn | 0:33bfb28b0ffc | 23 | while(1) |
sgrsn | 0:33bfb28b0ffc | 24 | { |
sgrsn | 0:33bfb28b0ffc | 25 | wait_ms(1500); |
sgrsn | 0:33bfb28b0ffc | 26 | jrk.setTarget(2500); |
sgrsn | 0:33bfb28b0ffc | 27 | wait_ms(1500); |
sgrsn | 0:33bfb28b0ffc | 28 | jrk.setTarget(1500); |
sgrsn | 0:33bfb28b0ffc | 29 | } |
sgrsn | 0:33bfb28b0ffc | 30 | } |
sgrsn | 0:33bfb28b0ffc | 31 | |
sgrsn | 0:33bfb28b0ffc | 32 | ***********************************************/ |
sgrsn | 0:33bfb28b0ffc | 33 | |
sgrsn | 0:33bfb28b0ffc | 34 | /// This is used to represent a null or missing value for some of the Jrk G2's |
sgrsn | 0:33bfb28b0ffc | 35 | /// 16-bit input variables. |
sgrsn | 0:33bfb28b0ffc | 36 | const uint16_t JrkG2InputNull = 0xFFFF; |
sgrsn | 0:33bfb28b0ffc | 37 | |
sgrsn | 0:33bfb28b0ffc | 38 | /// This value is returned by getLastError() if the last communication with the |
sgrsn | 0:33bfb28b0ffc | 39 | /// device resulted in an unsuccessful read (e.g. timeout or NACK). |
sgrsn | 0:33bfb28b0ffc | 40 | const uint8_t JrkG2CommReadError = 50; |
sgrsn | 0:33bfb28b0ffc | 41 | |
sgrsn | 0:33bfb28b0ffc | 42 | /// This enum defines the Jrk's error bits. See the "Error handling" section of |
sgrsn | 0:33bfb28b0ffc | 43 | /// the Jrk G2 user's guide for more information about what these errors mean. |
sgrsn | 0:33bfb28b0ffc | 44 | /// |
sgrsn | 0:33bfb28b0ffc | 45 | /// See JrkG2Base::getErrorFlagsHalting() and JrkG2Base::getErrorFlagsOccurred(). |
sgrsn | 0:33bfb28b0ffc | 46 | enum JrkG2Error |
sgrsn | 0:33bfb28b0ffc | 47 | { |
sgrsn | 0:33bfb28b0ffc | 48 | AwaitingCommand = 0, |
sgrsn | 0:33bfb28b0ffc | 49 | NoPower = 1, |
sgrsn | 0:33bfb28b0ffc | 50 | MotorDriver = 2, |
sgrsn | 0:33bfb28b0ffc | 51 | InputInvalid = 3, |
sgrsn | 0:33bfb28b0ffc | 52 | InputDisconnect = 4, |
sgrsn | 0:33bfb28b0ffc | 53 | FeedbackDisconnect = 5, |
sgrsn | 0:33bfb28b0ffc | 54 | SoftOvercurrent = 6, |
sgrsn | 0:33bfb28b0ffc | 55 | SerialSignal = 7, |
sgrsn | 0:33bfb28b0ffc | 56 | SerialOverrun = 8, |
sgrsn | 0:33bfb28b0ffc | 57 | SerialBufferFull = 9, |
sgrsn | 0:33bfb28b0ffc | 58 | SerialCrc = 10, |
sgrsn | 0:33bfb28b0ffc | 59 | SerialProtocol = 11, |
sgrsn | 0:33bfb28b0ffc | 60 | SerialTimeout = 12, |
sgrsn | 0:33bfb28b0ffc | 61 | HardOvercurrent = 13, |
sgrsn | 0:33bfb28b0ffc | 62 | }; |
sgrsn | 0:33bfb28b0ffc | 63 | |
sgrsn | 0:33bfb28b0ffc | 64 | /// This enum defines the Jrk G2 command bytes which are used for its serial and |
sgrsn | 0:33bfb28b0ffc | 65 | /// I2C interfaces. These bytes are used by the library and you should not need |
sgrsn | 0:33bfb28b0ffc | 66 | /// to use them. |
sgrsn | 0:33bfb28b0ffc | 67 | enum JrkG2Command |
sgrsn | 0:33bfb28b0ffc | 68 | { |
sgrsn | 0:33bfb28b0ffc | 69 | SetTarget = 0xC0, |
sgrsn | 0:33bfb28b0ffc | 70 | SetTargetLowResRev = 0xE0, |
sgrsn | 0:33bfb28b0ffc | 71 | SetTargetLowResFwd = 0xE1, |
sgrsn | 0:33bfb28b0ffc | 72 | ForceDutyCycleTarget = 0xF2, |
sgrsn | 0:33bfb28b0ffc | 73 | ForceDutyCycle = 0xF4, |
sgrsn | 0:33bfb28b0ffc | 74 | MotorOff = 0xFF, |
sgrsn | 0:33bfb28b0ffc | 75 | GetVariable8 = 0x80, |
sgrsn | 0:33bfb28b0ffc | 76 | GetVariable16 = 0xA0, |
sgrsn | 0:33bfb28b0ffc | 77 | GetEEPROMSettings = 0xE3, |
sgrsn | 0:33bfb28b0ffc | 78 | GetVariables = 0xE5, |
sgrsn | 0:33bfb28b0ffc | 79 | SetRAMSettings = 0xE6, |
sgrsn | 0:33bfb28b0ffc | 80 | GetRAMSettings = 0xEA, |
sgrsn | 0:33bfb28b0ffc | 81 | GetCurrentChoppingOccurrenceCount = 0xEC, |
sgrsn | 0:33bfb28b0ffc | 82 | }; |
sgrsn | 0:33bfb28b0ffc | 83 | |
sgrsn | 0:33bfb28b0ffc | 84 | /// This enum defines the modes in which the Jrk G2's duty cycle target or duty |
sgrsn | 0:33bfb28b0ffc | 85 | /// cycle, normally derived from the output of its PID algorithm, can be |
sgrsn | 0:33bfb28b0ffc | 86 | /// overridden with a forced value. |
sgrsn | 0:33bfb28b0ffc | 87 | /// |
sgrsn | 0:33bfb28b0ffc | 88 | /// See JrkG2Base::getForceMode(), JrkG2Base::forceDutyCycleTarget(), and |
sgrsn | 0:33bfb28b0ffc | 89 | /// JrkG2Base::forceDutyCycle(). |
sgrsn | 0:33bfb28b0ffc | 90 | enum JrkG2ForceMode |
sgrsn | 0:33bfb28b0ffc | 91 | { |
sgrsn | 0:33bfb28b0ffc | 92 | None = 0, |
sgrsn | 0:33bfb28b0ffc | 93 | DutyCycleTarget = 1, |
sgrsn | 0:33bfb28b0ffc | 94 | DutyCycle = 2, |
sgrsn | 0:33bfb28b0ffc | 95 | }; |
sgrsn | 0:33bfb28b0ffc | 96 | |
sgrsn | 0:33bfb28b0ffc | 97 | /// This enum defines the possible causes of a full microcontroller reset for |
sgrsn | 0:33bfb28b0ffc | 98 | /// the Jrk G2. |
sgrsn | 0:33bfb28b0ffc | 99 | /// |
sgrsn | 0:33bfb28b0ffc | 100 | /// See JrkG2Base::getDeviceReset(). |
sgrsn | 0:33bfb28b0ffc | 101 | enum JrkG2Reset |
sgrsn | 0:33bfb28b0ffc | 102 | { |
sgrsn | 0:33bfb28b0ffc | 103 | PowerUp = 0, |
sgrsn | 0:33bfb28b0ffc | 104 | Brownout = 1, |
sgrsn | 0:33bfb28b0ffc | 105 | ResetLine = 2, |
sgrsn | 0:33bfb28b0ffc | 106 | Watchdog = 4, |
sgrsn | 0:33bfb28b0ffc | 107 | Software = 8, |
sgrsn | 0:33bfb28b0ffc | 108 | StackOverflow = 16, |
sgrsn | 0:33bfb28b0ffc | 109 | StackUnderflow = 32, |
sgrsn | 0:33bfb28b0ffc | 110 | }; |
sgrsn | 0:33bfb28b0ffc | 111 | |
sgrsn | 0:33bfb28b0ffc | 112 | /// This enum defines the Jrk G2's control and feedback pins |
sgrsn | 0:33bfb28b0ffc | 113 | enum JrkG2Pin |
sgrsn | 0:33bfb28b0ffc | 114 | { |
sgrsn | 0:33bfb28b0ffc | 115 | SCL = 0, |
sgrsn | 0:33bfb28b0ffc | 116 | SDA = 1, |
sgrsn | 0:33bfb28b0ffc | 117 | TX = 2, |
sgrsn | 0:33bfb28b0ffc | 118 | RX = 3, |
sgrsn | 0:33bfb28b0ffc | 119 | RC = 4, |
sgrsn | 0:33bfb28b0ffc | 120 | AUX = 5, |
sgrsn | 0:33bfb28b0ffc | 121 | FBA = 6, |
sgrsn | 0:33bfb28b0ffc | 122 | FBT = 7, |
sgrsn | 0:33bfb28b0ffc | 123 | }; |
sgrsn | 0:33bfb28b0ffc | 124 | |
sgrsn | 0:33bfb28b0ffc | 125 | /// This enum defines the bits in the Jrk G2's Options Byte 3 register. You |
sgrsn | 0:33bfb28b0ffc | 126 | /// should not need to use this directly. See JrkG2Base::setResetIntegral(), |
sgrsn | 0:33bfb28b0ffc | 127 | /// JrkG2Base::getResetIntegral(), JrkG2Base::setCoastWhenOff(), and |
sgrsn | 0:33bfb28b0ffc | 128 | /// JrkG2Base::getCoastWhenOff(). |
sgrsn | 0:33bfb28b0ffc | 129 | enum JrkG2OptionsByte3 |
sgrsn | 0:33bfb28b0ffc | 130 | { |
sgrsn | 0:33bfb28b0ffc | 131 | ResetIntegral = 0, |
sgrsn | 0:33bfb28b0ffc | 132 | CoastWhenOff = 1, |
sgrsn | 0:33bfb28b0ffc | 133 | }; |
sgrsn | 0:33bfb28b0ffc | 134 | |
sgrsn | 0:33bfb28b0ffc | 135 | /// This is a base class used to represent a connection to a Jrk G2. This class |
sgrsn | 0:33bfb28b0ffc | 136 | /// provides high-level functions for sending commands to the Jrk and reading |
sgrsn | 0:33bfb28b0ffc | 137 | /// data from it. |
sgrsn | 0:33bfb28b0ffc | 138 | /// |
sgrsn | 0:33bfb28b0ffc | 139 | /// See the subclasses of this class, JrkG2Serial and JrkG2I2C. |
sgrsn | 0:33bfb28b0ffc | 140 | class JrkG2Base |
sgrsn | 0:33bfb28b0ffc | 141 | { |
sgrsn | 0:33bfb28b0ffc | 142 | public: |
sgrsn | 0:33bfb28b0ffc | 143 | |
sgrsn | 0:33bfb28b0ffc | 144 | JrkG2Base() |
sgrsn | 0:33bfb28b0ffc | 145 | { |
sgrsn | 0:33bfb28b0ffc | 146 | _lastError = 0; |
sgrsn | 0:33bfb28b0ffc | 147 | } |
sgrsn | 0:33bfb28b0ffc | 148 | |
sgrsn | 0:33bfb28b0ffc | 149 | /// Returns 0 if the last communication with the device was successful, and |
sgrsn | 0:33bfb28b0ffc | 150 | /// non-zero if there was an error. |
sgrsn | 0:33bfb28b0ffc | 151 | uint8_t getLastError() |
sgrsn | 0:33bfb28b0ffc | 152 | { |
sgrsn | 0:33bfb28b0ffc | 153 | return _lastError; |
sgrsn | 0:33bfb28b0ffc | 154 | } |
sgrsn | 0:33bfb28b0ffc | 155 | /// Sets the target of the Jrk to a value in the range 0 to 4095. |
sgrsn | 0:33bfb28b0ffc | 156 | /// |
sgrsn | 0:33bfb28b0ffc | 157 | /// The target can represent a target duty cycle, speed, or position depending |
sgrsn | 0:33bfb28b0ffc | 158 | /// on the feedback mode. |
sgrsn | 0:33bfb28b0ffc | 159 | /// |
sgrsn | 0:33bfb28b0ffc | 160 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 161 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 162 | /// jrkG2.setTarget(3000); |
sgrsn | 0:33bfb28b0ffc | 163 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 164 | /// |
sgrsn | 0:33bfb28b0ffc | 165 | /// This functions sends a "Set target" command to the jrk, which clears the |
sgrsn | 0:33bfb28b0ffc | 166 | /// "Awaiting command" error bit and (if the input mode is serial) will set |
sgrsn | 0:33bfb28b0ffc | 167 | /// the jrk's input and target variables. |
sgrsn | 0:33bfb28b0ffc | 168 | /// |
sgrsn | 0:33bfb28b0ffc | 169 | /// See also setTargetLowResRev(), setTargetLowResFwd(), getTarget(), |
sgrsn | 0:33bfb28b0ffc | 170 | /// forceDutyCycleTarget(), forceDutyCycle(). |
sgrsn | 0:33bfb28b0ffc | 171 | |
sgrsn | 0:33bfb28b0ffc | 172 | void setTarget(uint16_t target) |
sgrsn | 0:33bfb28b0ffc | 173 | { |
sgrsn | 0:33bfb28b0ffc | 174 | // lower 5 bits in command byte |
sgrsn | 0:33bfb28b0ffc | 175 | // upper 7 bits in data byte |
sgrsn | 0:33bfb28b0ffc | 176 | if (target > 4095) { target = 4095; } |
sgrsn | 0:33bfb28b0ffc | 177 | commandW7((uint8_t)SetTarget | (target & 0x1F), target >> 5); |
sgrsn | 0:33bfb28b0ffc | 178 | } |
sgrsn | 0:33bfb28b0ffc | 179 | |
sgrsn | 0:33bfb28b0ffc | 180 | /// Sets the target of the Jrk based on a value in the range 0 to 127. |
sgrsn | 0:33bfb28b0ffc | 181 | /// |
sgrsn | 0:33bfb28b0ffc | 182 | /// If the value is zero, then this command is equivalent to the "Stop motor" |
sgrsn | 0:33bfb28b0ffc | 183 | /// command. Otherwise, the value maps to a 12-bit target less than 2048. |
sgrsn | 0:33bfb28b0ffc | 184 | /// |
sgrsn | 0:33bfb28b0ffc | 185 | /// If the feedback mode is Analog or Tachometer, then the formula is |
sgrsn | 0:33bfb28b0ffc | 186 | /// Target = 2048 - 16 * value. |
sgrsn | 0:33bfb28b0ffc | 187 | /// |
sgrsn | 0:33bfb28b0ffc | 188 | /// If the feedback mode is None (speed control mode), then the formula is |
sgrsn | 0:33bfb28b0ffc | 189 | /// Target = 2048 - (600 / 127) * value. This means that a value of |
sgrsn | 0:33bfb28b0ffc | 190 | /// 127 will set the duty cycle target to full-speed reverse (-600). |
sgrsn | 0:33bfb28b0ffc | 191 | /// |
sgrsn | 0:33bfb28b0ffc | 192 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 193 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 194 | /// jrkG2.setTargetLowResRev(100); |
sgrsn | 0:33bfb28b0ffc | 195 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 196 | /// |
sgrsn | 0:33bfb28b0ffc | 197 | /// This function sends a "Set target low resolution reverse" command to the |
sgrsn | 0:33bfb28b0ffc | 198 | /// Jrk G2, which clears the "Awaiting command" error bit and (if the input |
sgrsn | 0:33bfb28b0ffc | 199 | /// mode is serial) will set the jrk's input and target variables. |
sgrsn | 0:33bfb28b0ffc | 200 | /// |
sgrsn | 0:33bfb28b0ffc | 201 | /// See also setTargetLowResFwd(), setTarget(), getTarget(), and stopMotor(). |
sgrsn | 0:33bfb28b0ffc | 202 | void setTargetLowResRev(uint8_t target) |
sgrsn | 0:33bfb28b0ffc | 203 | { |
sgrsn | 0:33bfb28b0ffc | 204 | if (target > 127) { target = 127; } |
sgrsn | 0:33bfb28b0ffc | 205 | commandW7(SetTargetLowResRev, target); |
sgrsn | 0:33bfb28b0ffc | 206 | } |
sgrsn | 0:33bfb28b0ffc | 207 | |
sgrsn | 0:33bfb28b0ffc | 208 | /// Sets the target of the Jrk based on a value in the range 0 to 127 that |
sgrsn | 0:33bfb28b0ffc | 209 | /// maps to a 12-bit target of 2048 or greater. |
sgrsn | 0:33bfb28b0ffc | 210 | /// |
sgrsn | 0:33bfb28b0ffc | 211 | /// If the feedback mode is Analog or Tachometer, then the formula is |
sgrsn | 0:33bfb28b0ffc | 212 | /// Target = 2048 + 16 * value. |
sgrsn | 0:33bfb28b0ffc | 213 | /// |
sgrsn | 0:33bfb28b0ffc | 214 | /// If the feedback mode is None (speed control mode), then the formula is |
sgrsn | 0:33bfb28b0ffc | 215 | /// Target = 2048 + (600 / 127) * value. This means that a value of 127 will |
sgrsn | 0:33bfb28b0ffc | 216 | /// set the duty cycle target to full-speed reverse (-600), while a value of |
sgrsn | 0:33bfb28b0ffc | 217 | /// zero will make the motor stop. |
sgrsn | 0:33bfb28b0ffc | 218 | /// |
sgrsn | 0:33bfb28b0ffc | 219 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 220 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 221 | /// jrkG2.setTargetLowResFwd(100); |
sgrsn | 0:33bfb28b0ffc | 222 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 223 | /// |
sgrsn | 0:33bfb28b0ffc | 224 | /// This function sends a "Set target low resolution forward" command to the |
sgrsn | 0:33bfb28b0ffc | 225 | /// Jrk G2, which clears the "Awaiting command" error bit and (if the input |
sgrsn | 0:33bfb28b0ffc | 226 | /// mode is serial) will set the jrk's input and target variables. |
sgrsn | 0:33bfb28b0ffc | 227 | /// |
sgrsn | 0:33bfb28b0ffc | 228 | /// See also setTargetLowResRev(), setTarget(), and getTarget(). |
sgrsn | 0:33bfb28b0ffc | 229 | void setTargetLowResFwd(uint8_t target) |
sgrsn | 0:33bfb28b0ffc | 230 | { |
sgrsn | 0:33bfb28b0ffc | 231 | if (target > 127) { target = 127; } |
sgrsn | 0:33bfb28b0ffc | 232 | commandW7(SetTargetLowResFwd, target); |
sgrsn | 0:33bfb28b0ffc | 233 | } |
sgrsn | 0:33bfb28b0ffc | 234 | |
sgrsn | 0:33bfb28b0ffc | 235 | /// Forces the duty cycle target of the Jrk to a value in the range |
sgrsn | 0:33bfb28b0ffc | 236 | /// -600 to +600. |
sgrsn | 0:33bfb28b0ffc | 237 | /// |
sgrsn | 0:33bfb28b0ffc | 238 | /// The Jrk will ignore the results of the usual algorithm for choosing the duty |
sgrsn | 0:33bfb28b0ffc | 239 | /// cycle target, and instead set it to be equal to the target specified by this |
sgrsn | 0:33bfb28b0ffc | 240 | /// command. The Jrk will set its 'Integral' variable to 0 while in this mode. |
sgrsn | 0:33bfb28b0ffc | 241 | /// |
sgrsn | 0:33bfb28b0ffc | 242 | /// This is useful if the Jrk is configured to use feedback but you want to take |
sgrsn | 0:33bfb28b0ffc | 243 | /// control of the motor for some time, while still respecting errors and motor |
sgrsn | 0:33bfb28b0ffc | 244 | /// limits as usual. |
sgrsn | 0:33bfb28b0ffc | 245 | /// |
sgrsn | 0:33bfb28b0ffc | 246 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 247 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 248 | /// jrkG2.forceDutyCycleTarget(250); |
sgrsn | 0:33bfb28b0ffc | 249 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 250 | /// |
sgrsn | 0:33bfb28b0ffc | 251 | /// This function sends a "Force duty cycle target" command to the Jrk G2, which |
sgrsn | 0:33bfb28b0ffc | 252 | /// clears the "Awaiting command" error bit. |
sgrsn | 0:33bfb28b0ffc | 253 | /// |
sgrsn | 0:33bfb28b0ffc | 254 | /// To get out of this mode, use setTarget(), setTargetLowResFwd(), |
sgrsn | 0:33bfb28b0ffc | 255 | /// setTargetLowResRev(), forceDutyCycle(), or stopMotor(). |
sgrsn | 0:33bfb28b0ffc | 256 | /// |
sgrsn | 0:33bfb28b0ffc | 257 | /// See also getForceMode(). |
sgrsn | 0:33bfb28b0ffc | 258 | void forceDutyCycleTarget(int16_t dutyCycle) |
sgrsn | 0:33bfb28b0ffc | 259 | { |
sgrsn | 0:33bfb28b0ffc | 260 | if (dutyCycle > 600) { dutyCycle = 600; } |
sgrsn | 0:33bfb28b0ffc | 261 | if (dutyCycle < -600) { dutyCycle = -600; } |
sgrsn | 0:33bfb28b0ffc | 262 | commandWs14(ForceDutyCycleTarget, dutyCycle); |
sgrsn | 0:33bfb28b0ffc | 263 | } |
sgrsn | 0:33bfb28b0ffc | 264 | |
sgrsn | 0:33bfb28b0ffc | 265 | /// Forces the duty cycle of the Jrk to a value in the range -600 to +600. |
sgrsn | 0:33bfb28b0ffc | 266 | /// |
sgrsn | 0:33bfb28b0ffc | 267 | /// The jrk will ignore the results of the usual algorithm for choosing the |
sgrsn | 0:33bfb28b0ffc | 268 | /// duty cycle, and instead set it to be equal to the value specified by this |
sgrsn | 0:33bfb28b0ffc | 269 | /// command, ignoring all motor limits except the maximum duty cycle |
sgrsn | 0:33bfb28b0ffc | 270 | /// parameters, and ignoring the 'Input invalid', 'Input disconnect', and |
sgrsn | 0:33bfb28b0ffc | 271 | /// 'Feedback disconnect' errors. This command will have an immediate effect, |
sgrsn | 0:33bfb28b0ffc | 272 | /// regardless of the PID period. The jrk will set its 'Integral' variable to |
sgrsn | 0:33bfb28b0ffc | 273 | /// 0 while in this mode. |
sgrsn | 0:33bfb28b0ffc | 274 | /// |
sgrsn | 0:33bfb28b0ffc | 275 | /// This is useful if the jrk is configured to use feedback but you want to take |
sgrsn | 0:33bfb28b0ffc | 276 | /// control of the motor for some time, without respecting most motor limits. |
sgrsn | 0:33bfb28b0ffc | 277 | /// |
sgrsn | 0:33bfb28b0ffc | 278 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 279 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 280 | /// jrkG2.forceDutyCycle(250); |
sgrsn | 0:33bfb28b0ffc | 281 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 282 | /// |
sgrsn | 0:33bfb28b0ffc | 283 | /// This function sends a "Force duty cycle" command to the Jrk G2, which |
sgrsn | 0:33bfb28b0ffc | 284 | /// clears the "Awaiting command" error bit. |
sgrsn | 0:33bfb28b0ffc | 285 | /// |
sgrsn | 0:33bfb28b0ffc | 286 | /// To get out of this mode, use setTarget(), setTargetLowResFwd(), |
sgrsn | 0:33bfb28b0ffc | 287 | /// setTargetLowResRev(), forceDutyCycleTarget(), or stopMotor(). |
sgrsn | 0:33bfb28b0ffc | 288 | /// |
sgrsn | 0:33bfb28b0ffc | 289 | /// See also getForceMode(). |
sgrsn | 0:33bfb28b0ffc | 290 | void forceDutyCycle(int16_t dutyCycle) |
sgrsn | 0:33bfb28b0ffc | 291 | { |
sgrsn | 0:33bfb28b0ffc | 292 | if (dutyCycle > 600) { dutyCycle = 600; } |
sgrsn | 0:33bfb28b0ffc | 293 | if (dutyCycle < -600) { dutyCycle = -600; } |
sgrsn | 0:33bfb28b0ffc | 294 | commandWs14(ForceDutyCycle, dutyCycle); |
sgrsn | 0:33bfb28b0ffc | 295 | } |
sgrsn | 0:33bfb28b0ffc | 296 | |
sgrsn | 0:33bfb28b0ffc | 297 | /// Turns the motor off. |
sgrsn | 0:33bfb28b0ffc | 298 | /// |
sgrsn | 0:33bfb28b0ffc | 299 | /// This function sends a "Stop motor" command to the Jrk, which sets the |
sgrsn | 0:33bfb28b0ffc | 300 | /// "Awaiting command" error bit. The Jrk will respect the configured |
sgrsn | 0:33bfb28b0ffc | 301 | /// deceleration limit while decelerating to a duty cycle of 0, unless the |
sgrsn | 0:33bfb28b0ffc | 302 | /// "Awaiting command" error has been configured as a hard error. Once the duty |
sgrsn | 0:33bfb28b0ffc | 303 | /// cycle reaches zero, the Jrk will either brake or coast. |
sgrsn | 0:33bfb28b0ffc | 304 | /// |
sgrsn | 0:33bfb28b0ffc | 305 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 306 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 307 | /// jrkG2.stopMotor(); |
sgrsn | 0:33bfb28b0ffc | 308 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 309 | void stopMotor() |
sgrsn | 0:33bfb28b0ffc | 310 | { |
sgrsn | 0:33bfb28b0ffc | 311 | commandQuick(MotorOff); |
sgrsn | 0:33bfb28b0ffc | 312 | } |
sgrsn | 0:33bfb28b0ffc | 313 | |
sgrsn | 0:33bfb28b0ffc | 314 | ///@} |
sgrsn | 0:33bfb28b0ffc | 315 | |
sgrsn | 0:33bfb28b0ffc | 316 | ///\name Variable reading commands |
sgrsn | 0:33bfb28b0ffc | 317 | ///@{ |
sgrsn | 0:33bfb28b0ffc | 318 | |
sgrsn | 0:33bfb28b0ffc | 319 | /// Gets the input variable. |
sgrsn | 0:33bfb28b0ffc | 320 | /// |
sgrsn | 0:33bfb28b0ffc | 321 | /// The input variable is a raw, unscaled value representing a measurement |
sgrsn | 0:33bfb28b0ffc | 322 | /// taken by the Jrk of the input to the system. In serial input mode, the |
sgrsn | 0:33bfb28b0ffc | 323 | /// input is equal to the target, which can be set to any value from 0 to 4095 |
sgrsn | 0:33bfb28b0ffc | 324 | /// using serial commands. In analog input mode, the input is a measurement |
sgrsn | 0:33bfb28b0ffc | 325 | /// of the voltage on the SDA pin, where 0 is 0 V and 4092 is a voltage equal |
sgrsn | 0:33bfb28b0ffc | 326 | /// to the Jrk's 5V pin (approximately 4.8 V). In RC input mode, the input is |
sgrsn | 0:33bfb28b0ffc | 327 | /// the duration of the last RC pulse measured, in units of 2/3 us. |
sgrsn | 0:33bfb28b0ffc | 328 | /// |
sgrsn | 0:33bfb28b0ffc | 329 | /// See the Jrk G2 user's guide for more information about input modes. |
sgrsn | 0:33bfb28b0ffc | 330 | /// |
sgrsn | 0:33bfb28b0ffc | 331 | /// See also getTarget() and setTarget(). |
sgrsn | 0:33bfb28b0ffc | 332 | uint16_t getInput() |
sgrsn | 0:33bfb28b0ffc | 333 | { |
sgrsn | 0:33bfb28b0ffc | 334 | return getVar16SingleByte(Input); |
sgrsn | 0:33bfb28b0ffc | 335 | } |
sgrsn | 0:33bfb28b0ffc | 336 | |
sgrsn | 0:33bfb28b0ffc | 337 | /// Gets the target variable. |
sgrsn | 0:33bfb28b0ffc | 338 | /// |
sgrsn | 0:33bfb28b0ffc | 339 | /// In serial input mode, the target is set directly with serial commands. In |
sgrsn | 0:33bfb28b0ffc | 340 | /// the other input modes, the target is computed by scaling the input, using |
sgrsn | 0:33bfb28b0ffc | 341 | /// the configurable input scaling settings. |
sgrsn | 0:33bfb28b0ffc | 342 | /// |
sgrsn | 0:33bfb28b0ffc | 343 | /// See also setTarget() and getInput(). |
sgrsn | 0:33bfb28b0ffc | 344 | uint16_t getTarget() |
sgrsn | 0:33bfb28b0ffc | 345 | { |
sgrsn | 0:33bfb28b0ffc | 346 | return getVar16SingleByte(Target); |
sgrsn | 0:33bfb28b0ffc | 347 | } |
sgrsn | 0:33bfb28b0ffc | 348 | |
sgrsn | 0:33bfb28b0ffc | 349 | /// Gets the feedback variable. |
sgrsn | 0:33bfb28b0ffc | 350 | /// |
sgrsn | 0:33bfb28b0ffc | 351 | /// The feedback variable is a raw, unscaled feedback value, representing a |
sgrsn | 0:33bfb28b0ffc | 352 | /// measurement taken by the Jrk of the output of the system. In analog |
sgrsn | 0:33bfb28b0ffc | 353 | /// feedback mode, the feedback is a measurement of the voltage on the FBA |
sgrsn | 0:33bfb28b0ffc | 354 | /// pin, where 0 is 0 V and 4092 is a voltage equal to the Jrk's 5V pin |
sgrsn | 0:33bfb28b0ffc | 355 | /// (approximately 4.8 V). In frequency feedback mode, the feedback is 2048 |
sgrsn | 0:33bfb28b0ffc | 356 | /// plus or minus a measurement of the frequency of pulses on the FBT pin. In |
sgrsn | 0:33bfb28b0ffc | 357 | /// feedback mode none (open-loop speed control mode), the feedback is always |
sgrsn | 0:33bfb28b0ffc | 358 | /// zero. |
sgrsn | 0:33bfb28b0ffc | 359 | /// |
sgrsn | 0:33bfb28b0ffc | 360 | /// See also getScaledFeedback(). |
sgrsn | 0:33bfb28b0ffc | 361 | uint16_t getFeedback() |
sgrsn | 0:33bfb28b0ffc | 362 | { |
sgrsn | 0:33bfb28b0ffc | 363 | return getVar16SingleByte(Feedback); |
sgrsn | 0:33bfb28b0ffc | 364 | } |
sgrsn | 0:33bfb28b0ffc | 365 | |
sgrsn | 0:33bfb28b0ffc | 366 | /// Gets the scaled feedback variable. |
sgrsn | 0:33bfb28b0ffc | 367 | /// |
sgrsn | 0:33bfb28b0ffc | 368 | /// The scaled feedback is calculated from the feedback using the Jrk's |
sgrsn | 0:33bfb28b0ffc | 369 | /// configurable feedback scaling settings. |
sgrsn | 0:33bfb28b0ffc | 370 | /// |
sgrsn | 0:33bfb28b0ffc | 371 | /// See also getFeedback(). |
sgrsn | 0:33bfb28b0ffc | 372 | uint16_t getScaledFeedback() |
sgrsn | 0:33bfb28b0ffc | 373 | { |
sgrsn | 0:33bfb28b0ffc | 374 | return getVar16SingleByte(ScaledFeedback); |
sgrsn | 0:33bfb28b0ffc | 375 | } |
sgrsn | 0:33bfb28b0ffc | 376 | |
sgrsn | 0:33bfb28b0ffc | 377 | /// Gets the integral variable. |
sgrsn | 0:33bfb28b0ffc | 378 | /// |
sgrsn | 0:33bfb28b0ffc | 379 | /// In general, every PID period, the error (scaled feedback minus target) is |
sgrsn | 0:33bfb28b0ffc | 380 | /// added to the integral (also known as error sum). There are several |
sgrsn | 0:33bfb28b0ffc | 381 | /// settings to configure the behavior of this variable, and it is used in the |
sgrsn | 0:33bfb28b0ffc | 382 | /// PID calculation. |
sgrsn | 0:33bfb28b0ffc | 383 | int16_t getIntegral() |
sgrsn | 0:33bfb28b0ffc | 384 | { |
sgrsn | 0:33bfb28b0ffc | 385 | return getVar16SingleByte(Integral); |
sgrsn | 0:33bfb28b0ffc | 386 | } |
sgrsn | 0:33bfb28b0ffc | 387 | |
sgrsn | 0:33bfb28b0ffc | 388 | /// Gets the duty cycle target variable. |
sgrsn | 0:33bfb28b0ffc | 389 | /// |
sgrsn | 0:33bfb28b0ffc | 390 | /// In general, this is the duty cycle that the Jrk is trying to achieve. A |
sgrsn | 0:33bfb28b0ffc | 391 | /// value of -600 or less means full speed reverse, while a value of 600 or |
sgrsn | 0:33bfb28b0ffc | 392 | /// more means full speed forward. A value of 0 means stopped (braking or |
sgrsn | 0:33bfb28b0ffc | 393 | /// coasting). In no feedback mode (open-loop speed control mode), the duty |
sgrsn | 0:33bfb28b0ffc | 394 | /// cycle target is normally the target minus 2048. In other feedback modes, |
sgrsn | 0:33bfb28b0ffc | 395 | /// the duty cycle target is normally the sum of the proportional, integral, |
sgrsn | 0:33bfb28b0ffc | 396 | /// and derivative terms of the PID algorithm. In any mode, the duty cycle |
sgrsn | 0:33bfb28b0ffc | 397 | /// target can be overridden with forceDutyCycleTarget(). |
sgrsn | 0:33bfb28b0ffc | 398 | /// |
sgrsn | 0:33bfb28b0ffc | 399 | /// If an error is stopping the motor, the duty cycle target variable will not |
sgrsn | 0:33bfb28b0ffc | 400 | /// be directly affected, but the duty cycle variable will change/decelerate |
sgrsn | 0:33bfb28b0ffc | 401 | /// to zero. |
sgrsn | 0:33bfb28b0ffc | 402 | /// |
sgrsn | 0:33bfb28b0ffc | 403 | /// See also getDutyCycle(), getLastDutyCycle(), and forceDutyCycleTarget(). |
sgrsn | 0:33bfb28b0ffc | 404 | int16_t getDutyCycleTarget() |
sgrsn | 0:33bfb28b0ffc | 405 | { |
sgrsn | 0:33bfb28b0ffc | 406 | return getVar16SingleByte(DutyCycleTarget); |
sgrsn | 0:33bfb28b0ffc | 407 | } |
sgrsn | 0:33bfb28b0ffc | 408 | |
sgrsn | 0:33bfb28b0ffc | 409 | /// Gets the duty cycle variable. |
sgrsn | 0:33bfb28b0ffc | 410 | /// |
sgrsn | 0:33bfb28b0ffc | 411 | /// The duty cycle variable is the duty cycle at which the jrk is currently |
sgrsn | 0:33bfb28b0ffc | 412 | /// driving the motor. A value of -600 means full speed reverse, while a |
sgrsn | 0:33bfb28b0ffc | 413 | /// value of 600 means full speed forward. A value of 0 means stopped |
sgrsn | 0:33bfb28b0ffc | 414 | /// (braking or coasting). The duty cycle could be different from the duty |
sgrsn | 0:33bfb28b0ffc | 415 | /// cycle target because it normally takes into account the Jrk's configurable |
sgrsn | 0:33bfb28b0ffc | 416 | /// motor limits and errors. The duty cycle can be overridden with |
sgrsn | 0:33bfb28b0ffc | 417 | /// forceDutyCycle(). |
sgrsn | 0:33bfb28b0ffc | 418 | /// |
sgrsn | 0:33bfb28b0ffc | 419 | /// See also getLastDutyCycle(), getDutyCycleTarget(), and forceDutyCycle(). |
sgrsn | 0:33bfb28b0ffc | 420 | int16_t getDutyCycle() |
sgrsn | 0:33bfb28b0ffc | 421 | { |
sgrsn | 0:33bfb28b0ffc | 422 | return getVar16SingleByte(DutyCycle); |
sgrsn | 0:33bfb28b0ffc | 423 | } |
sgrsn | 0:33bfb28b0ffc | 424 | |
sgrsn | 0:33bfb28b0ffc | 425 | /// Gets the most-significant 8 bits of the "Current" variable. |
sgrsn | 0:33bfb28b0ffc | 426 | /// |
sgrsn | 0:33bfb28b0ffc | 427 | /// The Jrk G2 supports this command mainly to be compatible with older Jrk |
sgrsn | 0:33bfb28b0ffc | 428 | /// models. In new applications, we recommend using getCurrent(), which |
sgrsn | 0:33bfb28b0ffc | 429 | /// provides a higher-resolution measurement. |
sgrsn | 0:33bfb28b0ffc | 430 | uint8_t getCurrentLowRes() |
sgrsn | 0:33bfb28b0ffc | 431 | { |
sgrsn | 0:33bfb28b0ffc | 432 | return getVar8SingleByte(CurrentLowRes); |
sgrsn | 0:33bfb28b0ffc | 433 | } |
sgrsn | 0:33bfb28b0ffc | 434 | |
sgrsn | 0:33bfb28b0ffc | 435 | /// Returns true if the Jrk's most recent PID cycle took more time than the |
sgrsn | 0:33bfb28b0ffc | 436 | /// configured PID period. This indicates that the Jrk does not have time to |
sgrsn | 0:33bfb28b0ffc | 437 | /// perform all of its tasks at the desired rate. Most often, this is caused |
sgrsn | 0:33bfb28b0ffc | 438 | /// by the configured number of analog samples for input, feedback, or current |
sgrsn | 0:33bfb28b0ffc | 439 | /// sensing being too high for the configured PID period. |
sgrsn | 0:33bfb28b0ffc | 440 | bool getPIDPeriodExceeded() |
sgrsn | 0:33bfb28b0ffc | 441 | { |
sgrsn | 0:33bfb28b0ffc | 442 | return getVar8SingleByte(PIDPeriodExceeded); |
sgrsn | 0:33bfb28b0ffc | 443 | } |
sgrsn | 0:33bfb28b0ffc | 444 | |
sgrsn | 0:33bfb28b0ffc | 445 | /// Get the "PID period count" variable, which is the number of PID periods |
sgrsn | 0:33bfb28b0ffc | 446 | /// that have elapsed. It resets to 0 after reaching 65535. The duration of |
sgrsn | 0:33bfb28b0ffc | 447 | /// the PID period can be configured. |
sgrsn | 0:33bfb28b0ffc | 448 | uint16_t getPIDPeriodCount() |
sgrsn | 0:33bfb28b0ffc | 449 | { |
sgrsn | 0:33bfb28b0ffc | 450 | return getVar16SingleByte(PIDPeriodCount); |
sgrsn | 0:33bfb28b0ffc | 451 | } |
sgrsn | 0:33bfb28b0ffc | 452 | |
sgrsn | 0:33bfb28b0ffc | 453 | /// Gets the errors that are currently stopping the motor and clears any |
sgrsn | 0:33bfb28b0ffc | 454 | /// latched errors that are enabled. Calling this function is equivalent to |
sgrsn | 0:33bfb28b0ffc | 455 | /// reading the "Currently stopping motor?" column in the Errors tab of the |
sgrsn | 0:33bfb28b0ffc | 456 | /// configuration utility, and then clicking the "Clear Errors" button. |
sgrsn | 0:33bfb28b0ffc | 457 | /// |
sgrsn | 0:33bfb28b0ffc | 458 | /// Each bit in the returned register represents a different error. The bits |
sgrsn | 0:33bfb28b0ffc | 459 | /// are defined in the ::JrkG2Error enum. |
sgrsn | 0:33bfb28b0ffc | 460 | /// |
sgrsn | 0:33bfb28b0ffc | 461 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 462 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 463 | /// uint16_t errors = jrk.getErrorFlagsHalting(); |
sgrsn | 0:33bfb28b0ffc | 464 | /// if (errors & (1 << (uint8_t)JrkG2Error::NoPower)) |
sgrsn | 0:33bfb28b0ffc | 465 | /// { |
sgrsn | 0:33bfb28b0ffc | 466 | /// // handle loss of power |
sgrsn | 0:33bfb28b0ffc | 467 | /// } |
sgrsn | 0:33bfb28b0ffc | 468 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 469 | /// |
sgrsn | 0:33bfb28b0ffc | 470 | /// It is possible to read this variable without clearing the bits in it using |
sgrsn | 0:33bfb28b0ffc | 471 | /// a getVariables(). |
sgrsn | 0:33bfb28b0ffc | 472 | /// |
sgrsn | 0:33bfb28b0ffc | 473 | /// See also getErrorFlagsOccurred(). |
sgrsn | 0:33bfb28b0ffc | 474 | uint16_t getErrorFlagsHalting() |
sgrsn | 0:33bfb28b0ffc | 475 | { |
sgrsn | 0:33bfb28b0ffc | 476 | return getVar16SingleByte(ErrorFlagsHalting); |
sgrsn | 0:33bfb28b0ffc | 477 | } |
sgrsn | 0:33bfb28b0ffc | 478 | |
sgrsn | 0:33bfb28b0ffc | 479 | /// Gets the errors that have occurred since the last time this function was |
sgrsn | 0:33bfb28b0ffc | 480 | /// called. Unlike getErrorFlagsHalting(), calling this function has no |
sgrsn | 0:33bfb28b0ffc | 481 | /// effect on the motor. |
sgrsn | 0:33bfb28b0ffc | 482 | /// |
sgrsn | 0:33bfb28b0ffc | 483 | /// Note that the Jrk G2 Control Center constantly clears the bits in this |
sgrsn | 0:33bfb28b0ffc | 484 | /// register, so if you are running the Jrk G2 Control Center then you will |
sgrsn | 0:33bfb28b0ffc | 485 | /// not be able to reliably detect errors with this function. |
sgrsn | 0:33bfb28b0ffc | 486 | /// |
sgrsn | 0:33bfb28b0ffc | 487 | /// Each bit in the returned register represents a different error. The bits |
sgrsn | 0:33bfb28b0ffc | 488 | /// are defined in the ::JrkG2Error enum. |
sgrsn | 0:33bfb28b0ffc | 489 | /// |
sgrsn | 0:33bfb28b0ffc | 490 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 491 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 492 | /// uint32_t errors = jrk.getErrorsOccurred(); |
sgrsn | 0:33bfb28b0ffc | 493 | /// if (errors & (1 << (uint8_t)JrkG2Error::MotorDriver)) |
sgrsn | 0:33bfb28b0ffc | 494 | /// { |
sgrsn | 0:33bfb28b0ffc | 495 | /// // handle a motor driver error |
sgrsn | 0:33bfb28b0ffc | 496 | /// } |
sgrsn | 0:33bfb28b0ffc | 497 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 498 | /// |
sgrsn | 0:33bfb28b0ffc | 499 | /// It is possible to read this variable without clearing the bits in it using |
sgrsn | 0:33bfb28b0ffc | 500 | /// getVariables(). |
sgrsn | 0:33bfb28b0ffc | 501 | /// |
sgrsn | 0:33bfb28b0ffc | 502 | /// See also getErrorFlagsHalting(). |
sgrsn | 0:33bfb28b0ffc | 503 | uint16_t getErrorFlagsOccurred() |
sgrsn | 0:33bfb28b0ffc | 504 | { |
sgrsn | 0:33bfb28b0ffc | 505 | return getVar16SingleByte(ErrorFlagsOccurred); |
sgrsn | 0:33bfb28b0ffc | 506 | } |
sgrsn | 0:33bfb28b0ffc | 507 | |
sgrsn | 0:33bfb28b0ffc | 508 | /// Returns an indication of whether the Jrk's duty cycle target or duty cycle |
sgrsn | 0:33bfb28b0ffc | 509 | /// are being overridden with a forced value. |
sgrsn | 0:33bfb28b0ffc | 510 | /// |
sgrsn | 0:33bfb28b0ffc | 511 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 512 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 513 | /// if (jrk.getForceMode() == JrkG2ForceMode::DutyCycleTarget) |
sgrsn | 0:33bfb28b0ffc | 514 | /// { |
sgrsn | 0:33bfb28b0ffc | 515 | /// // The duty cycle target is being overridden with a forced value. |
sgrsn | 0:33bfb28b0ffc | 516 | /// } |
sgrsn | 0:33bfb28b0ffc | 517 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 518 | /// |
sgrsn | 0:33bfb28b0ffc | 519 | /// See also forceDutyCycleTarget() and forceDutyCycle(). |
sgrsn | 0:33bfb28b0ffc | 520 | JrkG2ForceMode getForceMode() |
sgrsn | 0:33bfb28b0ffc | 521 | { |
sgrsn | 0:33bfb28b0ffc | 522 | return (JrkG2ForceMode)(getVar8SingleByte(FlagByte1) & 0x03); |
sgrsn | 0:33bfb28b0ffc | 523 | } |
sgrsn | 0:33bfb28b0ffc | 524 | |
sgrsn | 0:33bfb28b0ffc | 525 | /// Gets the measurement of the VIN voltage, in millivolts. |
sgrsn | 0:33bfb28b0ffc | 526 | /// |
sgrsn | 0:33bfb28b0ffc | 527 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 528 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 529 | /// uint16_t vin = jrk.getVinVoltage(); |
sgrsn | 0:33bfb28b0ffc | 530 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 531 | uint16_t getVinVoltage() |
sgrsn | 0:33bfb28b0ffc | 532 | { |
sgrsn | 0:33bfb28b0ffc | 533 | return getVar16SingleByte(VinVoltage); |
sgrsn | 0:33bfb28b0ffc | 534 | } |
sgrsn | 0:33bfb28b0ffc | 535 | |
sgrsn | 0:33bfb28b0ffc | 536 | /// Gets the Jrk's measurement of the current running through the motor, in |
sgrsn | 0:33bfb28b0ffc | 537 | /// milliamps. |
sgrsn | 0:33bfb28b0ffc | 538 | uint16_t getCurrent() |
sgrsn | 0:33bfb28b0ffc | 539 | { |
sgrsn | 0:33bfb28b0ffc | 540 | return getVar16SingleByte(Current); |
sgrsn | 0:33bfb28b0ffc | 541 | } |
sgrsn | 0:33bfb28b0ffc | 542 | |
sgrsn | 0:33bfb28b0ffc | 543 | /// Gets the cause of the Jrk's last full microcontroller reset. |
sgrsn | 0:33bfb28b0ffc | 544 | /// |
sgrsn | 0:33bfb28b0ffc | 545 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 546 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 547 | /// if (jrk.getDeviceReset() == JrkG2Reset::Brownout) |
sgrsn | 0:33bfb28b0ffc | 548 | /// { |
sgrsn | 0:33bfb28b0ffc | 549 | /// // There was a brownout reset; the power supply could not keep up. |
sgrsn | 0:33bfb28b0ffc | 550 | /// } |
sgrsn | 0:33bfb28b0ffc | 551 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 552 | JrkG2Reset getDeviceReset() |
sgrsn | 0:33bfb28b0ffc | 553 | { |
sgrsn | 0:33bfb28b0ffc | 554 | return (JrkG2Reset)getVar8(DeviceReset); |
sgrsn | 0:33bfb28b0ffc | 555 | } |
sgrsn | 0:33bfb28b0ffc | 556 | |
sgrsn | 0:33bfb28b0ffc | 557 | /// Gets the time since the last full reset of the Jrk's microcontroller, in |
sgrsn | 0:33bfb28b0ffc | 558 | /// milliseconds. |
sgrsn | 0:33bfb28b0ffc | 559 | /// |
sgrsn | 0:33bfb28b0ffc | 560 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 561 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 562 | /// uint32_t upTime = jrk.getUpTime(); |
sgrsn | 0:33bfb28b0ffc | 563 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 564 | uint32_t getUpTime() |
sgrsn | 0:33bfb28b0ffc | 565 | { |
sgrsn | 0:33bfb28b0ffc | 566 | return getVar32(UpTime); |
sgrsn | 0:33bfb28b0ffc | 567 | } |
sgrsn | 0:33bfb28b0ffc | 568 | |
sgrsn | 0:33bfb28b0ffc | 569 | /// Gets the raw RC pulse width measured on the Jrk's RC input, in units of |
sgrsn | 0:33bfb28b0ffc | 570 | /// twelfths of a microsecond. |
sgrsn | 0:33bfb28b0ffc | 571 | /// |
sgrsn | 0:33bfb28b0ffc | 572 | /// Returns 0 if the RC input is missing or invalid. |
sgrsn | 0:33bfb28b0ffc | 573 | /// |
sgrsn | 0:33bfb28b0ffc | 574 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 575 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 576 | /// uint16_t pulseWidth = jrk.getRCPulseWidth(); |
sgrsn | 0:33bfb28b0ffc | 577 | /// if (pulseWidth != 0 && pulseWidth < 18000) |
sgrsn | 0:33bfb28b0ffc | 578 | /// { |
sgrsn | 0:33bfb28b0ffc | 579 | /// // Input is valid and pulse width is less than 1500 microseconds. |
sgrsn | 0:33bfb28b0ffc | 580 | /// } |
sgrsn | 0:33bfb28b0ffc | 581 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 582 | uint16_t getRCPulseWidth() |
sgrsn | 0:33bfb28b0ffc | 583 | { |
sgrsn | 0:33bfb28b0ffc | 584 | return getVar16(RCPulseWidth); |
sgrsn | 0:33bfb28b0ffc | 585 | } |
sgrsn | 0:33bfb28b0ffc | 586 | |
sgrsn | 0:33bfb28b0ffc | 587 | /// Gets the raw pulse rate or pulse width measured on the Jrk's FBT |
sgrsn | 0:33bfb28b0ffc | 588 | /// (tachometer feedback) pin. |
sgrsn | 0:33bfb28b0ffc | 589 | /// |
sgrsn | 0:33bfb28b0ffc | 590 | /// In pulse counting mode, this will be the number of pulses on the FBT pin |
sgrsn | 0:33bfb28b0ffc | 591 | /// seen in the last N PID periods, where N is the "Pulse samples" setting. |
sgrsn | 0:33bfb28b0ffc | 592 | /// |
sgrsn | 0:33bfb28b0ffc | 593 | /// In pulse timing mode, this will be a measurement of the width of pulses on |
sgrsn | 0:33bfb28b0ffc | 594 | /// the FBT pin. This measurement is affected by several configurable |
sgrsn | 0:33bfb28b0ffc | 595 | /// settings. |
sgrsn | 0:33bfb28b0ffc | 596 | /// |
sgrsn | 0:33bfb28b0ffc | 597 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 598 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 599 | /// uint16_t fbtReading = jrk.getFBTReading(); |
sgrsn | 0:33bfb28b0ffc | 600 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 601 | uint16_t getFBTReading() |
sgrsn | 0:33bfb28b0ffc | 602 | { |
sgrsn | 0:33bfb28b0ffc | 603 | return getVar16(FBTReading); |
sgrsn | 0:33bfb28b0ffc | 604 | } |
sgrsn | 0:33bfb28b0ffc | 605 | |
sgrsn | 0:33bfb28b0ffc | 606 | /// Gets the analog reading from the specified pin. |
sgrsn | 0:33bfb28b0ffc | 607 | /// |
sgrsn | 0:33bfb28b0ffc | 608 | /// The reading is left-justified, so 0xFFFE represents a voltage equal to the |
sgrsn | 0:33bfb28b0ffc | 609 | /// Jrk's 5V pin (approximately 4.8 V). |
sgrsn | 0:33bfb28b0ffc | 610 | /// |
sgrsn | 0:33bfb28b0ffc | 611 | /// Returns JrkG2InputNull if the analog reading is disabled or not ready or |
sgrsn | 0:33bfb28b0ffc | 612 | /// the pin is invalid. |
sgrsn | 0:33bfb28b0ffc | 613 | /// |
sgrsn | 0:33bfb28b0ffc | 614 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 615 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 616 | /// uint16_t reading = getAnalogReading(JrkG2Pin::SDA); |
sgrsn | 0:33bfb28b0ffc | 617 | /// if (reading != JrkG2InputNull && reading < 32768) |
sgrsn | 0:33bfb28b0ffc | 618 | /// { |
sgrsn | 0:33bfb28b0ffc | 619 | /// // The reading is less than about 2.4 V. |
sgrsn | 0:33bfb28b0ffc | 620 | /// } |
sgrsn | 0:33bfb28b0ffc | 621 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 622 | uint16_t getAnalogReading(JrkG2Pin pin) |
sgrsn | 0:33bfb28b0ffc | 623 | { |
sgrsn | 0:33bfb28b0ffc | 624 | switch (pin) |
sgrsn | 0:33bfb28b0ffc | 625 | { |
sgrsn | 0:33bfb28b0ffc | 626 | case SDA: |
sgrsn | 0:33bfb28b0ffc | 627 | return getVar16(AnalogReadingSDA); |
sgrsn | 0:33bfb28b0ffc | 628 | case FBA: |
sgrsn | 0:33bfb28b0ffc | 629 | return getVar16(AnalogReadingFBA); |
sgrsn | 0:33bfb28b0ffc | 630 | default: |
sgrsn | 0:33bfb28b0ffc | 631 | return JrkG2InputNull; |
sgrsn | 0:33bfb28b0ffc | 632 | } |
sgrsn | 0:33bfb28b0ffc | 633 | } |
sgrsn | 0:33bfb28b0ffc | 634 | |
sgrsn | 0:33bfb28b0ffc | 635 | /// Gets a digital reading from the specified pin. |
sgrsn | 0:33bfb28b0ffc | 636 | /// |
sgrsn | 0:33bfb28b0ffc | 637 | /// A return value of 0 means low while 1 means high. In most cases, pins |
sgrsn | 0:33bfb28b0ffc | 638 | /// configured as analog inputs cannot be read as digital inputs, so their |
sgrsn | 0:33bfb28b0ffc | 639 | /// values will be 0. See getAnalogReading() for those pins. |
sgrsn | 0:33bfb28b0ffc | 640 | /// |
sgrsn | 0:33bfb28b0ffc | 641 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 642 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 643 | /// if (jrk.getDigitalReading(JrkG2Pin::RC)) |
sgrsn | 0:33bfb28b0ffc | 644 | /// { |
sgrsn | 0:33bfb28b0ffc | 645 | /// // Something is driving the RC pin high. |
sgrsn | 0:33bfb28b0ffc | 646 | /// } |
sgrsn | 0:33bfb28b0ffc | 647 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 648 | bool getDigitalReading(JrkG2Pin pin) |
sgrsn | 0:33bfb28b0ffc | 649 | { |
sgrsn | 0:33bfb28b0ffc | 650 | uint8_t readings = getVar8(DigitalReadings); |
sgrsn | 0:33bfb28b0ffc | 651 | return (readings >> (uint8_t)pin) & 1; |
sgrsn | 0:33bfb28b0ffc | 652 | } |
sgrsn | 0:33bfb28b0ffc | 653 | |
sgrsn | 0:33bfb28b0ffc | 654 | /// Gets the Jrk's raw measurement of the current running through the motor. |
sgrsn | 0:33bfb28b0ffc | 655 | /// |
sgrsn | 0:33bfb28b0ffc | 656 | /// This is an analog voltage reading from the Jrk's current sense |
sgrsn | 0:33bfb28b0ffc | 657 | /// pin. The units of the reading depend on what hard current limit is being |
sgrsn | 0:33bfb28b0ffc | 658 | /// used (getEncodedHardCurrentLimit()). |
sgrsn | 0:33bfb28b0ffc | 659 | /// |
sgrsn | 0:33bfb28b0ffc | 660 | /// See also getCurrent(). |
sgrsn | 0:33bfb28b0ffc | 661 | uint16_t getRawCurrent() |
sgrsn | 0:33bfb28b0ffc | 662 | { |
sgrsn | 0:33bfb28b0ffc | 663 | return getVar16(RawCurrent); |
sgrsn | 0:33bfb28b0ffc | 664 | } |
sgrsn | 0:33bfb28b0ffc | 665 | |
sgrsn | 0:33bfb28b0ffc | 666 | /// Gets the encoded value representing the hardware current limit the jrk is |
sgrsn | 0:33bfb28b0ffc | 667 | /// currently using. |
sgrsn | 0:33bfb28b0ffc | 668 | /// |
sgrsn | 0:33bfb28b0ffc | 669 | /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21. |
sgrsn | 0:33bfb28b0ffc | 670 | /// The Jrk G2 21v3 does not have a configurable hard current limit. |
sgrsn | 0:33bfb28b0ffc | 671 | /// |
sgrsn | 0:33bfb28b0ffc | 672 | /// See also setEncodedHardCurrentLimit(), getCurrent(). |
sgrsn | 0:33bfb28b0ffc | 673 | uint16_t getEncodedHardCurrentLimit() |
sgrsn | 0:33bfb28b0ffc | 674 | { |
sgrsn | 0:33bfb28b0ffc | 675 | return getVar16(EncodedHardCurrentLimit); |
sgrsn | 0:33bfb28b0ffc | 676 | } |
sgrsn | 0:33bfb28b0ffc | 677 | |
sgrsn | 0:33bfb28b0ffc | 678 | /// Gets the duty cycle the Jrk drove the motor with in the last PID period. |
sgrsn | 0:33bfb28b0ffc | 679 | /// |
sgrsn | 0:33bfb28b0ffc | 680 | /// This can be useful for converting the getRawCurrent() reading into |
sgrsn | 0:33bfb28b0ffc | 681 | /// milliamps. |
sgrsn | 0:33bfb28b0ffc | 682 | /// |
sgrsn | 0:33bfb28b0ffc | 683 | /// See also getDutyCycle(), getDutyCycleTarget(), and getCurrent(). |
sgrsn | 0:33bfb28b0ffc | 684 | int16_t getLastDutyCycle() |
sgrsn | 0:33bfb28b0ffc | 685 | { |
sgrsn | 0:33bfb28b0ffc | 686 | return getVar16(LastDutyCycle); |
sgrsn | 0:33bfb28b0ffc | 687 | } |
sgrsn | 0:33bfb28b0ffc | 688 | |
sgrsn | 0:33bfb28b0ffc | 689 | /// Gets the number of consecutive PID periods during which current chopping |
sgrsn | 0:33bfb28b0ffc | 690 | /// due to the hard current limit has been active. |
sgrsn | 0:33bfb28b0ffc | 691 | /// |
sgrsn | 0:33bfb28b0ffc | 692 | /// See also getCurrentChoppingOccurrenceCount(). |
sgrsn | 0:33bfb28b0ffc | 693 | uint8_t getCurrentChoppingConsecutiveCount() |
sgrsn | 0:33bfb28b0ffc | 694 | { |
sgrsn | 0:33bfb28b0ffc | 695 | return getVar8(CurrentChoppingConsecutiveCount); |
sgrsn | 0:33bfb28b0ffc | 696 | } |
sgrsn | 0:33bfb28b0ffc | 697 | |
sgrsn | 0:33bfb28b0ffc | 698 | /// Gets and clears the "Current chopping occurrence count" variable, which is |
sgrsn | 0:33bfb28b0ffc | 699 | /// the number of PID periods during which current chopping due to the hard |
sgrsn | 0:33bfb28b0ffc | 700 | /// current limit has been active, since the last time the variable was |
sgrsn | 0:33bfb28b0ffc | 701 | /// cleared. |
sgrsn | 0:33bfb28b0ffc | 702 | /// |
sgrsn | 0:33bfb28b0ffc | 703 | /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21. |
sgrsn | 0:33bfb28b0ffc | 704 | /// The Jrk G2 21v3 cannot sense when current chopping occurs so this command |
sgrsn | 0:33bfb28b0ffc | 705 | /// will always return 0. |
sgrsn | 0:33bfb28b0ffc | 706 | /// |
sgrsn | 0:33bfb28b0ffc | 707 | /// See also getCurrentChoppingConsecutiveCount(). |
sgrsn | 0:33bfb28b0ffc | 708 | uint8_t getCurrentChoppingOccurrenceCount() |
sgrsn | 0:33bfb28b0ffc | 709 | { |
sgrsn | 0:33bfb28b0ffc | 710 | return commandR8(GetCurrentChoppingOccurrenceCount); |
sgrsn | 0:33bfb28b0ffc | 711 | } |
sgrsn | 0:33bfb28b0ffc | 712 | ///@} |
sgrsn | 0:33bfb28b0ffc | 713 | |
sgrsn | 0:33bfb28b0ffc | 714 | ///\name RAM settings commands |
sgrsn | 0:33bfb28b0ffc | 715 | ///@{ |
sgrsn | 0:33bfb28b0ffc | 716 | |
sgrsn | 0:33bfb28b0ffc | 717 | /// Sets or clears the "Reset integral" setting in the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 718 | /// |
sgrsn | 0:33bfb28b0ffc | 719 | /// If this setting is set to true, the PID algorithm will reset the integral |
sgrsn | 0:33bfb28b0ffc | 720 | /// variable (also known as error sum) when the absolute value of the |
sgrsn | 0:33bfb28b0ffc | 721 | /// proportional term exceeds 600. |
sgrsn | 0:33bfb28b0ffc | 722 | /// |
sgrsn | 0:33bfb28b0ffc | 723 | /// When enabled, this can help limit integral wind-up, or the uncontrolled |
sgrsn | 0:33bfb28b0ffc | 724 | /// growth of the integral when the feedback system is temporarily unable to |
sgrsn | 0:33bfb28b0ffc | 725 | /// keep the error small. This might happen, for example, when the target is |
sgrsn | 0:33bfb28b0ffc | 726 | /// changing quickly. |
sgrsn | 0:33bfb28b0ffc | 727 | /// |
sgrsn | 0:33bfb28b0ffc | 728 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 729 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 730 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 731 | /// |
sgrsn | 0:33bfb28b0ffc | 732 | /// See also getResetIntegral(). |
sgrsn | 0:33bfb28b0ffc | 733 | void setResetIntegral(bool reset) |
sgrsn | 0:33bfb28b0ffc | 734 | { |
sgrsn | 0:33bfb28b0ffc | 735 | uint8_t tmp = getRAMSetting8(OptionsByte3); |
sgrsn | 0:33bfb28b0ffc | 736 | if (getLastError()) { return; } |
sgrsn | 0:33bfb28b0ffc | 737 | if (reset) |
sgrsn | 0:33bfb28b0ffc | 738 | { |
sgrsn | 0:33bfb28b0ffc | 739 | tmp |= 1 << (uint8_t)ResetIntegral; |
sgrsn | 0:33bfb28b0ffc | 740 | } |
sgrsn | 0:33bfb28b0ffc | 741 | else |
sgrsn | 0:33bfb28b0ffc | 742 | { |
sgrsn | 0:33bfb28b0ffc | 743 | tmp &= ~(1 << (uint8_t)ResetIntegral); |
sgrsn | 0:33bfb28b0ffc | 744 | } |
sgrsn | 0:33bfb28b0ffc | 745 | setRAMSetting8(OptionsByte3, tmp); |
sgrsn | 0:33bfb28b0ffc | 746 | } |
sgrsn | 0:33bfb28b0ffc | 747 | |
sgrsn | 0:33bfb28b0ffc | 748 | /// Gets the "Reset integral" setting from the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 749 | /// |
sgrsn | 0:33bfb28b0ffc | 750 | /// See also setResetIntegral(). |
sgrsn | 0:33bfb28b0ffc | 751 | bool getResetIntegral() |
sgrsn | 0:33bfb28b0ffc | 752 | { |
sgrsn | 0:33bfb28b0ffc | 753 | return getRAMSetting8(OptionsByte3) >> |
sgrsn | 0:33bfb28b0ffc | 754 | (uint8_t)ResetIntegral & 1; |
sgrsn | 0:33bfb28b0ffc | 755 | } |
sgrsn | 0:33bfb28b0ffc | 756 | |
sgrsn | 0:33bfb28b0ffc | 757 | /// Sets or clears the "Coast when off" setting in the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 758 | /// |
sgrsn | 0:33bfb28b0ffc | 759 | /// By default, the Jrk drives both motor outputs low when the motor is |
sgrsn | 0:33bfb28b0ffc | 760 | /// stopped (duty cycle is zero), causing it to brake. If enabled, this |
sgrsn | 0:33bfb28b0ffc | 761 | /// setting causes it to instead tri-state both outputs, making the motor |
sgrsn | 0:33bfb28b0ffc | 762 | /// coast. |
sgrsn | 0:33bfb28b0ffc | 763 | /// |
sgrsn | 0:33bfb28b0ffc | 764 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 765 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 766 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 767 | /// |
sgrsn | 0:33bfb28b0ffc | 768 | /// See also getCoastWhenOff(). |
sgrsn | 0:33bfb28b0ffc | 769 | void setCoastWhenOff(bool coast) |
sgrsn | 0:33bfb28b0ffc | 770 | { |
sgrsn | 0:33bfb28b0ffc | 771 | uint8_t tmp = getRAMSetting8(OptionsByte3); |
sgrsn | 0:33bfb28b0ffc | 772 | if (getLastError()) { return; } |
sgrsn | 0:33bfb28b0ffc | 773 | if (coast) |
sgrsn | 0:33bfb28b0ffc | 774 | { |
sgrsn | 0:33bfb28b0ffc | 775 | tmp |= 1 << (uint8_t)CoastWhenOff; |
sgrsn | 0:33bfb28b0ffc | 776 | } |
sgrsn | 0:33bfb28b0ffc | 777 | else |
sgrsn | 0:33bfb28b0ffc | 778 | { |
sgrsn | 0:33bfb28b0ffc | 779 | tmp &= ~(1 << (uint8_t)CoastWhenOff); |
sgrsn | 0:33bfb28b0ffc | 780 | } |
sgrsn | 0:33bfb28b0ffc | 781 | setRAMSetting8(OptionsByte3, tmp); |
sgrsn | 0:33bfb28b0ffc | 782 | } |
sgrsn | 0:33bfb28b0ffc | 783 | |
sgrsn | 0:33bfb28b0ffc | 784 | /// Gets the "Coast when off" setting from the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 785 | /// |
sgrsn | 0:33bfb28b0ffc | 786 | /// See also setCoastWhenOff(). |
sgrsn | 0:33bfb28b0ffc | 787 | bool getCoastWhenOff() |
sgrsn | 0:33bfb28b0ffc | 788 | { |
sgrsn | 0:33bfb28b0ffc | 789 | return getRAMSetting8(OptionsByte3) >> |
sgrsn | 0:33bfb28b0ffc | 790 | (uint8_t)CoastWhenOff & 1; |
sgrsn | 0:33bfb28b0ffc | 791 | } |
sgrsn | 0:33bfb28b0ffc | 792 | |
sgrsn | 0:33bfb28b0ffc | 793 | /// Sets the proportional coefficient in the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 794 | /// |
sgrsn | 0:33bfb28b0ffc | 795 | /// This coefficient is used in the Jrk's PID algorithm. The coefficient |
sgrsn | 0:33bfb28b0ffc | 796 | /// takes the form: |
sgrsn | 0:33bfb28b0ffc | 797 | /// |
sgrsn | 0:33bfb28b0ffc | 798 | /// multiplier / (2 ^ exponent) |
sgrsn | 0:33bfb28b0ffc | 799 | /// |
sgrsn | 0:33bfb28b0ffc | 800 | /// The multiplier can range from 0 to 1023, and the exponent can range |
sgrsn | 0:33bfb28b0ffc | 801 | /// from 0 to 18. |
sgrsn | 0:33bfb28b0ffc | 802 | /// |
sgrsn | 0:33bfb28b0ffc | 803 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 804 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 805 | /// // Set the proportional coefficient to 1.125 (9/(2^3)). |
sgrsn | 0:33bfb28b0ffc | 806 | /// jrk.setProportionalCoefficient(9, 3); |
sgrsn | 0:33bfb28b0ffc | 807 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 808 | /// |
sgrsn | 0:33bfb28b0ffc | 809 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 810 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 811 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 812 | /// |
sgrsn | 0:33bfb28b0ffc | 813 | /// See also getProportionalMultiplier() and getProportionalExponent(), as |
sgrsn | 0:33bfb28b0ffc | 814 | /// well as setIntegralCoefficient() and setDerivativeCoefficient(). |
sgrsn | 0:33bfb28b0ffc | 815 | void setProportionalCoefficient(uint16_t multiplier, uint8_t exponent) |
sgrsn | 0:33bfb28b0ffc | 816 | { |
sgrsn | 0:33bfb28b0ffc | 817 | setPIDCoefficient(ProportionalMultiplier, multiplier, exponent); |
sgrsn | 0:33bfb28b0ffc | 818 | } |
sgrsn | 0:33bfb28b0ffc | 819 | |
sgrsn | 0:33bfb28b0ffc | 820 | /// Gets the multiplier part of the proportional coefficient from the Jrk's |
sgrsn | 0:33bfb28b0ffc | 821 | /// RAM settings. |
sgrsn | 0:33bfb28b0ffc | 822 | /// |
sgrsn | 0:33bfb28b0ffc | 823 | /// See also getProportionalExponent() and setProportionalCoefficient(). |
sgrsn | 0:33bfb28b0ffc | 824 | uint16_t getProportionalMultiplier() |
sgrsn | 0:33bfb28b0ffc | 825 | { |
sgrsn | 0:33bfb28b0ffc | 826 | return getRAMSetting16(ProportionalMultiplier); |
sgrsn | 0:33bfb28b0ffc | 827 | } |
sgrsn | 0:33bfb28b0ffc | 828 | |
sgrsn | 0:33bfb28b0ffc | 829 | /// Gets the exponent part of the proportional coefficient from the Jrk's RAM |
sgrsn | 0:33bfb28b0ffc | 830 | /// settings. |
sgrsn | 0:33bfb28b0ffc | 831 | /// |
sgrsn | 0:33bfb28b0ffc | 832 | /// See also getProportionalMultiplier() and setProportionalCoefficient(). |
sgrsn | 0:33bfb28b0ffc | 833 | uint8_t getProportionalExponent() |
sgrsn | 0:33bfb28b0ffc | 834 | { |
sgrsn | 0:33bfb28b0ffc | 835 | return getRAMSetting8(ProportionalExponent); |
sgrsn | 0:33bfb28b0ffc | 836 | } |
sgrsn | 0:33bfb28b0ffc | 837 | |
sgrsn | 0:33bfb28b0ffc | 838 | /// Sets the integral coefficient in the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 839 | /// |
sgrsn | 0:33bfb28b0ffc | 840 | /// This coefficient is used in the Jrk's PID algorithm. The coefficient |
sgrsn | 0:33bfb28b0ffc | 841 | /// takes the form: |
sgrsn | 0:33bfb28b0ffc | 842 | /// |
sgrsn | 0:33bfb28b0ffc | 843 | /// multiplier / (2 ^ exponent) |
sgrsn | 0:33bfb28b0ffc | 844 | /// |
sgrsn | 0:33bfb28b0ffc | 845 | /// The multiplier can range from 0 to 1023, and the exponent can range |
sgrsn | 0:33bfb28b0ffc | 846 | /// from 0 to 18. |
sgrsn | 0:33bfb28b0ffc | 847 | /// |
sgrsn | 0:33bfb28b0ffc | 848 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 849 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 850 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 851 | /// |
sgrsn | 0:33bfb28b0ffc | 852 | /// See also getIntegralMultiplier() and getIntegralExponent(), as |
sgrsn | 0:33bfb28b0ffc | 853 | /// well as setProportionalCoefficient() and setDerivativeCoefficient(). |
sgrsn | 0:33bfb28b0ffc | 854 | void setIntegralCoefficient(uint16_t multiplier, uint8_t exponent) |
sgrsn | 0:33bfb28b0ffc | 855 | { |
sgrsn | 0:33bfb28b0ffc | 856 | setPIDCoefficient(IntegralMultiplier, multiplier, exponent); |
sgrsn | 0:33bfb28b0ffc | 857 | } |
sgrsn | 0:33bfb28b0ffc | 858 | |
sgrsn | 0:33bfb28b0ffc | 859 | /// Gets the multiplier part of the integral coefficient from the Jrk's |
sgrsn | 0:33bfb28b0ffc | 860 | /// RAM settings. |
sgrsn | 0:33bfb28b0ffc | 861 | /// |
sgrsn | 0:33bfb28b0ffc | 862 | /// See also getIntegralExponent() and setIntegralCoefficient(). |
sgrsn | 0:33bfb28b0ffc | 863 | uint16_t getIntegralMultiplier() |
sgrsn | 0:33bfb28b0ffc | 864 | { |
sgrsn | 0:33bfb28b0ffc | 865 | return getRAMSetting16(IntegralMultiplier); |
sgrsn | 0:33bfb28b0ffc | 866 | } |
sgrsn | 0:33bfb28b0ffc | 867 | |
sgrsn | 0:33bfb28b0ffc | 868 | /// Gets the exponent part of the integral coefficient from the Jrk's |
sgrsn | 0:33bfb28b0ffc | 869 | /// RAM settings. |
sgrsn | 0:33bfb28b0ffc | 870 | /// |
sgrsn | 0:33bfb28b0ffc | 871 | /// See also getIntegralMultiplier() and setIntegralCoefficient(). |
sgrsn | 0:33bfb28b0ffc | 872 | uint8_t getIntegralExponent() |
sgrsn | 0:33bfb28b0ffc | 873 | { |
sgrsn | 0:33bfb28b0ffc | 874 | return getRAMSetting8(IntegralExponent); |
sgrsn | 0:33bfb28b0ffc | 875 | } |
sgrsn | 0:33bfb28b0ffc | 876 | |
sgrsn | 0:33bfb28b0ffc | 877 | /// Sets the derivative coefficient in the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 878 | /// |
sgrsn | 0:33bfb28b0ffc | 879 | /// This coefficient is used in the Jrk's PID algorithm. The coefficient |
sgrsn | 0:33bfb28b0ffc | 880 | /// takes the form: |
sgrsn | 0:33bfb28b0ffc | 881 | /// |
sgrsn | 0:33bfb28b0ffc | 882 | /// multiplier / (2 ^ exponent) |
sgrsn | 0:33bfb28b0ffc | 883 | /// |
sgrsn | 0:33bfb28b0ffc | 884 | /// The multiplier can range from 0 to 1023, and the exponent can range |
sgrsn | 0:33bfb28b0ffc | 885 | /// from 0 to 18. |
sgrsn | 0:33bfb28b0ffc | 886 | /// |
sgrsn | 0:33bfb28b0ffc | 887 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 888 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 889 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 890 | /// |
sgrsn | 0:33bfb28b0ffc | 891 | /// See also getDerivativeMultiplier() and getDerivativeExponent(), as |
sgrsn | 0:33bfb28b0ffc | 892 | /// well as setProportionalCoefficient() and setIntegralCoefficient(). |
sgrsn | 0:33bfb28b0ffc | 893 | void setDerivativeCoefficient(uint16_t multiplier, uint8_t exponent) |
sgrsn | 0:33bfb28b0ffc | 894 | { |
sgrsn | 0:33bfb28b0ffc | 895 | setPIDCoefficient(DerivativeMultiplier, multiplier, exponent); |
sgrsn | 0:33bfb28b0ffc | 896 | } |
sgrsn | 0:33bfb28b0ffc | 897 | |
sgrsn | 0:33bfb28b0ffc | 898 | /// Gets the multiplier part of the derivative coefficient from the |
sgrsn | 0:33bfb28b0ffc | 899 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 900 | /// |
sgrsn | 0:33bfb28b0ffc | 901 | /// See also getDerivativeExponent() and setDerivativeCoefficient(). |
sgrsn | 0:33bfb28b0ffc | 902 | uint16_t getDerivativeMultiplier() |
sgrsn | 0:33bfb28b0ffc | 903 | { |
sgrsn | 0:33bfb28b0ffc | 904 | return getRAMSetting16(DerivativeMultiplier); |
sgrsn | 0:33bfb28b0ffc | 905 | } |
sgrsn | 0:33bfb28b0ffc | 906 | |
sgrsn | 0:33bfb28b0ffc | 907 | /// Gets the exponent part of the derivative coefficient from the |
sgrsn | 0:33bfb28b0ffc | 908 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 909 | /// |
sgrsn | 0:33bfb28b0ffc | 910 | /// See also getDerivativeMultiplier() and setDerivativeCoefficient(). |
sgrsn | 0:33bfb28b0ffc | 911 | uint8_t getDerivativeExponent() |
sgrsn | 0:33bfb28b0ffc | 912 | { |
sgrsn | 0:33bfb28b0ffc | 913 | return getRAMSetting8(DerivativeExponent); |
sgrsn | 0:33bfb28b0ffc | 914 | } |
sgrsn | 0:33bfb28b0ffc | 915 | |
sgrsn | 0:33bfb28b0ffc | 916 | /// Sets the PID period in the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 917 | /// |
sgrsn | 0:33bfb28b0ffc | 918 | /// This is the rate at which the Jrk runs through all of its calculations, in |
sgrsn | 0:33bfb28b0ffc | 919 | /// milliseconds. Note that a higher PID period will result in a more slowly |
sgrsn | 0:33bfb28b0ffc | 920 | /// changing integral and a higher derivative, so the two corresponding PID |
sgrsn | 0:33bfb28b0ffc | 921 | /// coefficients might need to be adjusted whenever the PID period is changed. |
sgrsn | 0:33bfb28b0ffc | 922 | /// |
sgrsn | 0:33bfb28b0ffc | 923 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 924 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 925 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 926 | /// |
sgrsn | 0:33bfb28b0ffc | 927 | /// See also getPIDPeriod(). |
sgrsn | 0:33bfb28b0ffc | 928 | void setPIDPeriod(uint16_t period) |
sgrsn | 0:33bfb28b0ffc | 929 | { |
sgrsn | 0:33bfb28b0ffc | 930 | setRAMSetting16(PIDPeriod, period); |
sgrsn | 0:33bfb28b0ffc | 931 | } |
sgrsn | 0:33bfb28b0ffc | 932 | |
sgrsn | 0:33bfb28b0ffc | 933 | /// Gets the PID period from the Jrk's RAM settings, in milliseconds. |
sgrsn | 0:33bfb28b0ffc | 934 | /// |
sgrsn | 0:33bfb28b0ffc | 935 | /// See also setPIDPeriod(). |
sgrsn | 0:33bfb28b0ffc | 936 | uint16_t getPIDPeriod() |
sgrsn | 0:33bfb28b0ffc | 937 | { |
sgrsn | 0:33bfb28b0ffc | 938 | return getRAMSetting16(PIDPeriod); |
sgrsn | 0:33bfb28b0ffc | 939 | } |
sgrsn | 0:33bfb28b0ffc | 940 | |
sgrsn | 0:33bfb28b0ffc | 941 | /// Sets the integral limit in the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 942 | /// |
sgrsn | 0:33bfb28b0ffc | 943 | /// The PID algorithm prevents the absolute value of the integral variable |
sgrsn | 0:33bfb28b0ffc | 944 | /// (also known as error sum) from exceeding this limit. This can help limit |
sgrsn | 0:33bfb28b0ffc | 945 | /// integral wind-up. The limit can range from 0 to 32767. |
sgrsn | 0:33bfb28b0ffc | 946 | /// |
sgrsn | 0:33bfb28b0ffc | 947 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 948 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 949 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 950 | /// |
sgrsn | 0:33bfb28b0ffc | 951 | /// See also getIntegralLimit(). |
sgrsn | 0:33bfb28b0ffc | 952 | void setIntegralLimit(uint16_t limit) |
sgrsn | 0:33bfb28b0ffc | 953 | { |
sgrsn | 0:33bfb28b0ffc | 954 | setRAMSetting16(IntegralLimit, limit); |
sgrsn | 0:33bfb28b0ffc | 955 | } |
sgrsn | 0:33bfb28b0ffc | 956 | |
sgrsn | 0:33bfb28b0ffc | 957 | /// Gets the integral limit from the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 958 | /// |
sgrsn | 0:33bfb28b0ffc | 959 | /// See also setIntegralLimit(). |
sgrsn | 0:33bfb28b0ffc | 960 | uint16_t getIntegralLimit() |
sgrsn | 0:33bfb28b0ffc | 961 | { |
sgrsn | 0:33bfb28b0ffc | 962 | return getRAMSetting16(IntegralLimit); |
sgrsn | 0:33bfb28b0ffc | 963 | } |
sgrsn | 0:33bfb28b0ffc | 964 | |
sgrsn | 0:33bfb28b0ffc | 965 | /// Sets the maximum duty cycle while feedback is out of range in the Jrk's |
sgrsn | 0:33bfb28b0ffc | 966 | /// RAM settings. |
sgrsn | 0:33bfb28b0ffc | 967 | /// |
sgrsn | 0:33bfb28b0ffc | 968 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 969 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 970 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 971 | /// |
sgrsn | 0:33bfb28b0ffc | 972 | /// See also getMaxDutyCycleWhileFeedbackOutOfRange(). |
sgrsn | 0:33bfb28b0ffc | 973 | void setMaxDutyCycleWhileFeedbackOutOfRange(uint16_t duty) |
sgrsn | 0:33bfb28b0ffc | 974 | { |
sgrsn | 0:33bfb28b0ffc | 975 | setRAMSetting16(MaxDutyCycleWhileFeedbackOutOfRange, duty); |
sgrsn | 0:33bfb28b0ffc | 976 | } |
sgrsn | 0:33bfb28b0ffc | 977 | |
sgrsn | 0:33bfb28b0ffc | 978 | /// Gets the maximum duty cycle while feedback is out of range from the Jrk's RAM |
sgrsn | 0:33bfb28b0ffc | 979 | /// settings. |
sgrsn | 0:33bfb28b0ffc | 980 | /// |
sgrsn | 0:33bfb28b0ffc | 981 | /// See also setMaxDutyCycleWhileFeedbackOutOfRange(). |
sgrsn | 0:33bfb28b0ffc | 982 | uint16_t getMaxDutyCycleWhileFeedbackOutOfRange() |
sgrsn | 0:33bfb28b0ffc | 983 | { |
sgrsn | 0:33bfb28b0ffc | 984 | return getRAMSetting16(MaxDutyCycleWhileFeedbackOutOfRange); |
sgrsn | 0:33bfb28b0ffc | 985 | } |
sgrsn | 0:33bfb28b0ffc | 986 | |
sgrsn | 0:33bfb28b0ffc | 987 | /// Sets the maximum acceleration in the forward direction in the |
sgrsn | 0:33bfb28b0ffc | 988 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 989 | /// |
sgrsn | 0:33bfb28b0ffc | 990 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 991 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 992 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 993 | /// |
sgrsn | 0:33bfb28b0ffc | 994 | /// See also getMaxAccelerationForward(), setMaxAccelerationReverse(), |
sgrsn | 0:33bfb28b0ffc | 995 | /// setMaxAcceleration(), and setMaxDecelerationForward(). |
sgrsn | 0:33bfb28b0ffc | 996 | void setMaxAccelerationForward(uint16_t accel) |
sgrsn | 0:33bfb28b0ffc | 997 | { |
sgrsn | 0:33bfb28b0ffc | 998 | setRAMSetting16(MaxAccelerationForward, accel); |
sgrsn | 0:33bfb28b0ffc | 999 | } |
sgrsn | 0:33bfb28b0ffc | 1000 | |
sgrsn | 0:33bfb28b0ffc | 1001 | /// Gets the maximum acceleration in the forward direction from the |
sgrsn | 0:33bfb28b0ffc | 1002 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1003 | /// |
sgrsn | 0:33bfb28b0ffc | 1004 | /// See also setMaxAccelerationForward(). |
sgrsn | 0:33bfb28b0ffc | 1005 | uint16_t getMaxAccelerationForward() |
sgrsn | 0:33bfb28b0ffc | 1006 | { |
sgrsn | 0:33bfb28b0ffc | 1007 | return getRAMSetting16(MaxAccelerationForward); |
sgrsn | 0:33bfb28b0ffc | 1008 | } |
sgrsn | 0:33bfb28b0ffc | 1009 | |
sgrsn | 0:33bfb28b0ffc | 1010 | /// Sets the maximum acceleration in the reverse direction in the |
sgrsn | 0:33bfb28b0ffc | 1011 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1012 | /// |
sgrsn | 0:33bfb28b0ffc | 1013 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1014 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1015 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1016 | /// |
sgrsn | 0:33bfb28b0ffc | 1017 | /// See also getMaxAccelerationReverse(), setMaxAccelerationForward(), |
sgrsn | 0:33bfb28b0ffc | 1018 | /// setMaxAcceleration(), and setMaxDecelerationReverse(). |
sgrsn | 0:33bfb28b0ffc | 1019 | void setMaxAccelerationReverse(uint16_t accel) |
sgrsn | 0:33bfb28b0ffc | 1020 | { |
sgrsn | 0:33bfb28b0ffc | 1021 | setRAMSetting16(MaxAccelerationReverse, accel); |
sgrsn | 0:33bfb28b0ffc | 1022 | } |
sgrsn | 0:33bfb28b0ffc | 1023 | |
sgrsn | 0:33bfb28b0ffc | 1024 | /// Gets the maximum acceleration in the reverse direction from the |
sgrsn | 0:33bfb28b0ffc | 1025 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1026 | /// |
sgrsn | 0:33bfb28b0ffc | 1027 | /// See also setMaxAccelerationReverse(). |
sgrsn | 0:33bfb28b0ffc | 1028 | uint16_t getMaxAccelerationReverse() |
sgrsn | 0:33bfb28b0ffc | 1029 | { |
sgrsn | 0:33bfb28b0ffc | 1030 | return getRAMSetting16(MaxAccelerationReverse); |
sgrsn | 0:33bfb28b0ffc | 1031 | } |
sgrsn | 0:33bfb28b0ffc | 1032 | |
sgrsn | 0:33bfb28b0ffc | 1033 | /// Sets the maximum acceleration in both directions in the |
sgrsn | 0:33bfb28b0ffc | 1034 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1035 | /// |
sgrsn | 0:33bfb28b0ffc | 1036 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1037 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1038 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1039 | /// |
sgrsn | 0:33bfb28b0ffc | 1040 | /// See also setMaxAccelerationForward(), setMaxAccelerationReverse(), |
sgrsn | 0:33bfb28b0ffc | 1041 | /// setMaxDeceleration(). |
sgrsn | 0:33bfb28b0ffc | 1042 | void setMaxAcceleration(uint16_t accel) |
sgrsn | 0:33bfb28b0ffc | 1043 | { |
sgrsn | 0:33bfb28b0ffc | 1044 | setRAMSetting16x2(MaxAccelerationForward, accel, accel); |
sgrsn | 0:33bfb28b0ffc | 1045 | } |
sgrsn | 0:33bfb28b0ffc | 1046 | |
sgrsn | 0:33bfb28b0ffc | 1047 | /// Sets the maximum deceleration in the forward direction in the Jrk's RAM |
sgrsn | 0:33bfb28b0ffc | 1048 | /// settings. |
sgrsn | 0:33bfb28b0ffc | 1049 | /// |
sgrsn | 0:33bfb28b0ffc | 1050 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1051 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1052 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1053 | /// |
sgrsn | 0:33bfb28b0ffc | 1054 | /// See also getMaxDecelerationForward(), setMaxDecelerationReverse(), |
sgrsn | 0:33bfb28b0ffc | 1055 | /// setMaxDeceleration(), and setMaxAccelerationForward(). |
sgrsn | 0:33bfb28b0ffc | 1056 | void setMaxDecelerationForward(uint16_t decel) |
sgrsn | 0:33bfb28b0ffc | 1057 | { |
sgrsn | 0:33bfb28b0ffc | 1058 | setRAMSetting16(MaxDecelerationForward, decel); |
sgrsn | 0:33bfb28b0ffc | 1059 | } |
sgrsn | 0:33bfb28b0ffc | 1060 | |
sgrsn | 0:33bfb28b0ffc | 1061 | /// Gets the maximum deceleration in the forward direction from the Jrk's RAM |
sgrsn | 0:33bfb28b0ffc | 1062 | /// settings. |
sgrsn | 0:33bfb28b0ffc | 1063 | /// |
sgrsn | 0:33bfb28b0ffc | 1064 | /// See also setMaxDecelerationForward(). |
sgrsn | 0:33bfb28b0ffc | 1065 | uint16_t getMaxDecelerationForward() |
sgrsn | 0:33bfb28b0ffc | 1066 | { |
sgrsn | 0:33bfb28b0ffc | 1067 | return getRAMSetting16(MaxDecelerationForward); |
sgrsn | 0:33bfb28b0ffc | 1068 | } |
sgrsn | 0:33bfb28b0ffc | 1069 | |
sgrsn | 0:33bfb28b0ffc | 1070 | /// Sets the maximum deceleration in the reverse direction in the |
sgrsn | 0:33bfb28b0ffc | 1071 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1072 | /// |
sgrsn | 0:33bfb28b0ffc | 1073 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1074 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1075 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1076 | /// |
sgrsn | 0:33bfb28b0ffc | 1077 | /// See also getMaxDecelerationReverse(), setMaxDecelerationForward(), |
sgrsn | 0:33bfb28b0ffc | 1078 | /// setMaxDeceleration(), and setMaxAccelerationReverse(). |
sgrsn | 0:33bfb28b0ffc | 1079 | void setMaxDecelerationReverse(uint16_t decel) |
sgrsn | 0:33bfb28b0ffc | 1080 | { |
sgrsn | 0:33bfb28b0ffc | 1081 | setRAMSetting16(MaxDecelerationReverse, decel); |
sgrsn | 0:33bfb28b0ffc | 1082 | } |
sgrsn | 0:33bfb28b0ffc | 1083 | |
sgrsn | 0:33bfb28b0ffc | 1084 | /// Gets the maximum deceleration in the reverse direction from the Jrk's RAM |
sgrsn | 0:33bfb28b0ffc | 1085 | /// settings. |
sgrsn | 0:33bfb28b0ffc | 1086 | /// |
sgrsn | 0:33bfb28b0ffc | 1087 | /// See also setMaxDecelerationReverse(). |
sgrsn | 0:33bfb28b0ffc | 1088 | uint16_t getMaxDecelerationReverse() |
sgrsn | 0:33bfb28b0ffc | 1089 | { |
sgrsn | 0:33bfb28b0ffc | 1090 | return getRAMSetting16(MaxDecelerationReverse); |
sgrsn | 0:33bfb28b0ffc | 1091 | } |
sgrsn | 0:33bfb28b0ffc | 1092 | |
sgrsn | 0:33bfb28b0ffc | 1093 | /// Sets the maximum deceleration in both directions in the |
sgrsn | 0:33bfb28b0ffc | 1094 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1095 | /// |
sgrsn | 0:33bfb28b0ffc | 1096 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1097 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1098 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1099 | /// |
sgrsn | 0:33bfb28b0ffc | 1100 | /// See also setMaxDecelerationForward(), setMaxDecelerationReverse(), |
sgrsn | 0:33bfb28b0ffc | 1101 | /// setMaxAcceleration(). |
sgrsn | 0:33bfb28b0ffc | 1102 | void setMaxDeceleration(uint16_t decel) |
sgrsn | 0:33bfb28b0ffc | 1103 | { |
sgrsn | 0:33bfb28b0ffc | 1104 | setRAMSetting16x2(MaxDecelerationForward, decel, decel); |
sgrsn | 0:33bfb28b0ffc | 1105 | } |
sgrsn | 0:33bfb28b0ffc | 1106 | |
sgrsn | 0:33bfb28b0ffc | 1107 | /// Sets the maximum duty cycle in the forward direction in the |
sgrsn | 0:33bfb28b0ffc | 1108 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1109 | /// |
sgrsn | 0:33bfb28b0ffc | 1110 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1111 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1112 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1113 | /// |
sgrsn | 0:33bfb28b0ffc | 1114 | /// See also getMaxDutyCycleForward(), setMaxDutyCycleReverse(). |
sgrsn | 0:33bfb28b0ffc | 1115 | void setMaxDutyCycleForward(uint16_t duty) |
sgrsn | 0:33bfb28b0ffc | 1116 | { |
sgrsn | 0:33bfb28b0ffc | 1117 | setRAMSetting16(MaxDutyCycleForward, duty); |
sgrsn | 0:33bfb28b0ffc | 1118 | } |
sgrsn | 0:33bfb28b0ffc | 1119 | |
sgrsn | 0:33bfb28b0ffc | 1120 | /// Gets the maximum duty cycle in the forward direction from the Jrk's RAM |
sgrsn | 0:33bfb28b0ffc | 1121 | /// settings. |
sgrsn | 0:33bfb28b0ffc | 1122 | /// |
sgrsn | 0:33bfb28b0ffc | 1123 | /// See also setMaxDutyCycleForward(). |
sgrsn | 0:33bfb28b0ffc | 1124 | uint16_t getMaxDutyCycleForward() |
sgrsn | 0:33bfb28b0ffc | 1125 | { |
sgrsn | 0:33bfb28b0ffc | 1126 | return getRAMSetting16(MaxDutyCycleForward); |
sgrsn | 0:33bfb28b0ffc | 1127 | } |
sgrsn | 0:33bfb28b0ffc | 1128 | |
sgrsn | 0:33bfb28b0ffc | 1129 | /// Sets the maximum duty cycle in the reverse direction in the |
sgrsn | 0:33bfb28b0ffc | 1130 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1131 | /// |
sgrsn | 0:33bfb28b0ffc | 1132 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1133 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1134 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1135 | /// |
sgrsn | 0:33bfb28b0ffc | 1136 | /// See also getMaxDutyCycleReverse(), setMaxDutyCycleForard(). |
sgrsn | 0:33bfb28b0ffc | 1137 | void setMaxDutyCycleReverse(uint16_t duty) |
sgrsn | 0:33bfb28b0ffc | 1138 | { |
sgrsn | 0:33bfb28b0ffc | 1139 | setRAMSetting16(MaxDutyCycleReverse, duty); |
sgrsn | 0:33bfb28b0ffc | 1140 | } |
sgrsn | 0:33bfb28b0ffc | 1141 | |
sgrsn | 0:33bfb28b0ffc | 1142 | /// Gets the maximum duty cycle in the reverse direction from the |
sgrsn | 0:33bfb28b0ffc | 1143 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1144 | /// |
sgrsn | 0:33bfb28b0ffc | 1145 | /// See also setMaxDutyCycleReverse(). |
sgrsn | 0:33bfb28b0ffc | 1146 | uint16_t getMaxDutyCycleReverse() |
sgrsn | 0:33bfb28b0ffc | 1147 | { |
sgrsn | 0:33bfb28b0ffc | 1148 | return getRAMSetting16(MaxDutyCycleReverse); |
sgrsn | 0:33bfb28b0ffc | 1149 | } |
sgrsn | 0:33bfb28b0ffc | 1150 | |
sgrsn | 0:33bfb28b0ffc | 1151 | /// Sets the maximum duty cycle for both directions in the |
sgrsn | 0:33bfb28b0ffc | 1152 | /// Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1153 | /// |
sgrsn | 0:33bfb28b0ffc | 1154 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1155 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1156 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1157 | /// |
sgrsn | 0:33bfb28b0ffc | 1158 | /// See also setMaxDutyCycleForward(), setMaxDutyCycleReverse(). |
sgrsn | 0:33bfb28b0ffc | 1159 | void setMaxDutyCycle(uint16_t duty) |
sgrsn | 0:33bfb28b0ffc | 1160 | { |
sgrsn | 0:33bfb28b0ffc | 1161 | setRAMSetting16x2(MaxDutyCycleForward, duty, duty); |
sgrsn | 0:33bfb28b0ffc | 1162 | } |
sgrsn | 0:33bfb28b0ffc | 1163 | |
sgrsn | 0:33bfb28b0ffc | 1164 | /// Sets the encoded hard current limit for driving in the forward direction |
sgrsn | 0:33bfb28b0ffc | 1165 | /// in the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1166 | /// |
sgrsn | 0:33bfb28b0ffc | 1167 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1168 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1169 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1170 | /// |
sgrsn | 0:33bfb28b0ffc | 1171 | /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21. |
sgrsn | 0:33bfb28b0ffc | 1172 | /// The Jrk G2 21v3 does not have a configurable hard current limit. |
sgrsn | 0:33bfb28b0ffc | 1173 | /// |
sgrsn | 0:33bfb28b0ffc | 1174 | /// See also getEncodedHardCurrentLimitForward() and |
sgrsn | 0:33bfb28b0ffc | 1175 | /// setEncodedHardCurrentLimitReverse(). |
sgrsn | 0:33bfb28b0ffc | 1176 | void setEncodedHardCurrentLimitForward(uint16_t encoded_limit) |
sgrsn | 0:33bfb28b0ffc | 1177 | { |
sgrsn | 0:33bfb28b0ffc | 1178 | setRAMSetting16(EncodedHardCurrentLimitForward, |
sgrsn | 0:33bfb28b0ffc | 1179 | encoded_limit); |
sgrsn | 0:33bfb28b0ffc | 1180 | } |
sgrsn | 0:33bfb28b0ffc | 1181 | |
sgrsn | 0:33bfb28b0ffc | 1182 | /// Gets the encoded hard current limit for driving in the forward direction |
sgrsn | 0:33bfb28b0ffc | 1183 | /// from the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1184 | /// |
sgrsn | 0:33bfb28b0ffc | 1185 | /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21. |
sgrsn | 0:33bfb28b0ffc | 1186 | /// The Jrk G2 21v3 does not have a configurable hard current limit. |
sgrsn | 0:33bfb28b0ffc | 1187 | /// |
sgrsn | 0:33bfb28b0ffc | 1188 | /// See also setEncodedHardCurrentLimitForward(). |
sgrsn | 0:33bfb28b0ffc | 1189 | uint16_t getEncodedHardCurrentLimitForward() |
sgrsn | 0:33bfb28b0ffc | 1190 | { |
sgrsn | 0:33bfb28b0ffc | 1191 | return getRAMSetting16(EncodedHardCurrentLimitForward); |
sgrsn | 0:33bfb28b0ffc | 1192 | } |
sgrsn | 0:33bfb28b0ffc | 1193 | |
sgrsn | 0:33bfb28b0ffc | 1194 | /// Sets the encoded hard current limit for driving in the reverse direction |
sgrsn | 0:33bfb28b0ffc | 1195 | /// in the Jrk's RAM settings |
sgrsn | 0:33bfb28b0ffc | 1196 | /// |
sgrsn | 0:33bfb28b0ffc | 1197 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1198 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1199 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1200 | /// |
sgrsn | 0:33bfb28b0ffc | 1201 | /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21. |
sgrsn | 0:33bfb28b0ffc | 1202 | /// The Jrk G2 21v3 does not have a configurable hard current limit. |
sgrsn | 0:33bfb28b0ffc | 1203 | /// |
sgrsn | 0:33bfb28b0ffc | 1204 | /// See also getEncodedHardCurrentLimitReverse() and |
sgrsn | 0:33bfb28b0ffc | 1205 | /// setEncodedHardCurrentLimitForward(). |
sgrsn | 0:33bfb28b0ffc | 1206 | void setEncodedHardCurrentLimitReverse(uint16_t encoded_limit) |
sgrsn | 0:33bfb28b0ffc | 1207 | { |
sgrsn | 0:33bfb28b0ffc | 1208 | setRAMSetting16(EncodedHardCurrentLimitReverse, encoded_limit); |
sgrsn | 0:33bfb28b0ffc | 1209 | } |
sgrsn | 0:33bfb28b0ffc | 1210 | |
sgrsn | 0:33bfb28b0ffc | 1211 | /// Gets the encoded hard current limit for driving in the reverse direction |
sgrsn | 0:33bfb28b0ffc | 1212 | /// from the Jrk's RAM settings. |
sgrsn | 0:33bfb28b0ffc | 1213 | /// |
sgrsn | 0:33bfb28b0ffc | 1214 | /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21. |
sgrsn | 0:33bfb28b0ffc | 1215 | /// The Jrk G2 21v3 does not have a configurable hard current limit. |
sgrsn | 0:33bfb28b0ffc | 1216 | /// |
sgrsn | 0:33bfb28b0ffc | 1217 | /// See also setEncodedHardCurrentLimitReverse(). |
sgrsn | 0:33bfb28b0ffc | 1218 | uint16_t getEncodedHardCurrentLimitReverse() |
sgrsn | 0:33bfb28b0ffc | 1219 | { |
sgrsn | 0:33bfb28b0ffc | 1220 | return getRAMSetting16(EncodedHardCurrentLimitReverse); |
sgrsn | 0:33bfb28b0ffc | 1221 | } |
sgrsn | 0:33bfb28b0ffc | 1222 | |
sgrsn | 0:33bfb28b0ffc | 1223 | /// Sets the encoded hard current limit for both directions in the Jrk's RAM |
sgrsn | 0:33bfb28b0ffc | 1224 | /// settings. |
sgrsn | 0:33bfb28b0ffc | 1225 | /// |
sgrsn | 0:33bfb28b0ffc | 1226 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1227 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1228 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1229 | /// |
sgrsn | 0:33bfb28b0ffc | 1230 | /// This command is only valid for the Jrk G2 18v19, 24v13, 18v27, and 24v21. |
sgrsn | 0:33bfb28b0ffc | 1231 | /// The Jrk G2 21v3 does not have a configurable hard current limit. |
sgrsn | 0:33bfb28b0ffc | 1232 | /// |
sgrsn | 0:33bfb28b0ffc | 1233 | /// See also setEncodedHardCurrentLimitForward(), |
sgrsn | 0:33bfb28b0ffc | 1234 | /// setEncodedHardCurrentLimitReverse(), getEncodedHardCurrentLimit(), and |
sgrsn | 0:33bfb28b0ffc | 1235 | /// setSoftCurrentLimit(). |
sgrsn | 0:33bfb28b0ffc | 1236 | void setEncodedHardCurrentLimit(uint16_t encoded_limit) |
sgrsn | 0:33bfb28b0ffc | 1237 | { |
sgrsn | 0:33bfb28b0ffc | 1238 | setRAMSetting16x2(EncodedHardCurrentLimitForward, |
sgrsn | 0:33bfb28b0ffc | 1239 | encoded_limit, encoded_limit); |
sgrsn | 0:33bfb28b0ffc | 1240 | } |
sgrsn | 0:33bfb28b0ffc | 1241 | |
sgrsn | 0:33bfb28b0ffc | 1242 | /// Sets the brake duration when switching from forward to reverse in the |
sgrsn | 0:33bfb28b0ffc | 1243 | /// Jrk's RAM settings, in units of 5 ms. |
sgrsn | 0:33bfb28b0ffc | 1244 | /// |
sgrsn | 0:33bfb28b0ffc | 1245 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1246 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1247 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1248 | /// |
sgrsn | 0:33bfb28b0ffc | 1249 | /// See also getBrakeDurationForward() and setBrakeDurationReverse(). |
sgrsn | 0:33bfb28b0ffc | 1250 | void setBrakeDurationForward(uint8_t duration) |
sgrsn | 0:33bfb28b0ffc | 1251 | { |
sgrsn | 0:33bfb28b0ffc | 1252 | setRAMSetting8(BrakeDurationForward, duration); |
sgrsn | 0:33bfb28b0ffc | 1253 | } |
sgrsn | 0:33bfb28b0ffc | 1254 | |
sgrsn | 0:33bfb28b0ffc | 1255 | /// Gets the brake duration when switching from forward to reverse from the |
sgrsn | 0:33bfb28b0ffc | 1256 | /// Jrk's RAM settings, in units of 5 ms. |
sgrsn | 0:33bfb28b0ffc | 1257 | /// |
sgrsn | 0:33bfb28b0ffc | 1258 | /// See also setBrakeDurationForward(). |
sgrsn | 0:33bfb28b0ffc | 1259 | uint8_t getBrakeDurationForward() |
sgrsn | 0:33bfb28b0ffc | 1260 | { |
sgrsn | 0:33bfb28b0ffc | 1261 | return getRAMSetting8(BrakeDurationForward); |
sgrsn | 0:33bfb28b0ffc | 1262 | } |
sgrsn | 0:33bfb28b0ffc | 1263 | |
sgrsn | 0:33bfb28b0ffc | 1264 | /// Sets the brake duration when switching from reverse to forward in the |
sgrsn | 0:33bfb28b0ffc | 1265 | /// Jrk's RAM settings, in units of 5 ms. |
sgrsn | 0:33bfb28b0ffc | 1266 | /// |
sgrsn | 0:33bfb28b0ffc | 1267 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1268 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1269 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1270 | /// |
sgrsn | 0:33bfb28b0ffc | 1271 | /// See also getBrakeDurationReverse() and setBrakeDurationForward(). |
sgrsn | 0:33bfb28b0ffc | 1272 | void setBrakeDurationReverse(uint8_t duration) |
sgrsn | 0:33bfb28b0ffc | 1273 | { |
sgrsn | 0:33bfb28b0ffc | 1274 | setRAMSetting8(BrakeDurationReverse, duration); |
sgrsn | 0:33bfb28b0ffc | 1275 | } |
sgrsn | 0:33bfb28b0ffc | 1276 | |
sgrsn | 0:33bfb28b0ffc | 1277 | /// Gets the brake duration when switching from reverse to forward from the |
sgrsn | 0:33bfb28b0ffc | 1278 | /// Jrk's RAM settings, in units of 5 ms. |
sgrsn | 0:33bfb28b0ffc | 1279 | /// |
sgrsn | 0:33bfb28b0ffc | 1280 | /// See also setBrakeDurationReverse(). |
sgrsn | 0:33bfb28b0ffc | 1281 | uint8_t getBrakeDurationReverse() |
sgrsn | 0:33bfb28b0ffc | 1282 | { |
sgrsn | 0:33bfb28b0ffc | 1283 | return getRAMSetting8(BrakeDurationReverse); |
sgrsn | 0:33bfb28b0ffc | 1284 | } |
sgrsn | 0:33bfb28b0ffc | 1285 | |
sgrsn | 0:33bfb28b0ffc | 1286 | /// Sets the brake duration for both directions in the Jrk's RAM settings, in |
sgrsn | 0:33bfb28b0ffc | 1287 | /// units of 5 ms. |
sgrsn | 0:33bfb28b0ffc | 1288 | /// |
sgrsn | 0:33bfb28b0ffc | 1289 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1290 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1291 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1292 | /// |
sgrsn | 0:33bfb28b0ffc | 1293 | /// See also setBrakeDurationForward(), setBrakeDurationReverse(). |
sgrsn | 0:33bfb28b0ffc | 1294 | void setBrakeDuration(uint8_t duration) |
sgrsn | 0:33bfb28b0ffc | 1295 | { |
sgrsn | 0:33bfb28b0ffc | 1296 | setRAMSetting8x2(BrakeDurationForward, duration, duration); |
sgrsn | 0:33bfb28b0ffc | 1297 | } |
sgrsn | 0:33bfb28b0ffc | 1298 | |
sgrsn | 0:33bfb28b0ffc | 1299 | /// Sets the soft current limit when driving in the forward direction in the |
sgrsn | 0:33bfb28b0ffc | 1300 | /// Jrk's RAM settings, in units of mA. |
sgrsn | 0:33bfb28b0ffc | 1301 | /// |
sgrsn | 0:33bfb28b0ffc | 1302 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1303 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1304 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1305 | /// |
sgrsn | 0:33bfb28b0ffc | 1306 | /// See also getSoftCurrentLimitForward() and setSoftCurrentLimitReverse(). |
sgrsn | 0:33bfb28b0ffc | 1307 | void setSoftCurrentLimitForward(uint16_t current) |
sgrsn | 0:33bfb28b0ffc | 1308 | { |
sgrsn | 0:33bfb28b0ffc | 1309 | setRAMSetting16(SoftCurrentLimitForward, current); |
sgrsn | 0:33bfb28b0ffc | 1310 | } |
sgrsn | 0:33bfb28b0ffc | 1311 | |
sgrsn | 0:33bfb28b0ffc | 1312 | /// Gets the soft current limit when driving in the forward direction from the |
sgrsn | 0:33bfb28b0ffc | 1313 | /// Jrk's RAM settings, in units of mA. |
sgrsn | 0:33bfb28b0ffc | 1314 | /// |
sgrsn | 0:33bfb28b0ffc | 1315 | /// See also setSoftCurrentLimitForward(). |
sgrsn | 0:33bfb28b0ffc | 1316 | uint16_t getSoftCurrentLimitForward() |
sgrsn | 0:33bfb28b0ffc | 1317 | { |
sgrsn | 0:33bfb28b0ffc | 1318 | return getRAMSetting16(SoftCurrentLimitForward); |
sgrsn | 0:33bfb28b0ffc | 1319 | } |
sgrsn | 0:33bfb28b0ffc | 1320 | |
sgrsn | 0:33bfb28b0ffc | 1321 | /// Sets the soft current limit when driving in the reverse direction in the |
sgrsn | 0:33bfb28b0ffc | 1322 | /// Jrk's RAM settings, in units of mA. |
sgrsn | 0:33bfb28b0ffc | 1323 | /// |
sgrsn | 0:33bfb28b0ffc | 1324 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1325 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1326 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1327 | /// |
sgrsn | 0:33bfb28b0ffc | 1328 | /// See also getSoftCurrentLimitReverse() and setSoftCurrentLimitForward(). |
sgrsn | 0:33bfb28b0ffc | 1329 | void setSoftCurrentLimitReverse(uint16_t current) |
sgrsn | 0:33bfb28b0ffc | 1330 | { |
sgrsn | 0:33bfb28b0ffc | 1331 | setRAMSetting16(SoftCurrentLimitReverse, current); |
sgrsn | 0:33bfb28b0ffc | 1332 | } |
sgrsn | 0:33bfb28b0ffc | 1333 | |
sgrsn | 0:33bfb28b0ffc | 1334 | /// Gets the soft current limit when driving in the reverse direction from the |
sgrsn | 0:33bfb28b0ffc | 1335 | /// Jrk's RAM settings, in units of mA. |
sgrsn | 0:33bfb28b0ffc | 1336 | /// |
sgrsn | 0:33bfb28b0ffc | 1337 | /// See also setSoftCurrentLimitReverse(). |
sgrsn | 0:33bfb28b0ffc | 1338 | uint16_t getSoftCurrentLimitReverse() |
sgrsn | 0:33bfb28b0ffc | 1339 | { |
sgrsn | 0:33bfb28b0ffc | 1340 | return getRAMSetting16(SoftCurrentLimitReverse); |
sgrsn | 0:33bfb28b0ffc | 1341 | } |
sgrsn | 0:33bfb28b0ffc | 1342 | |
sgrsn | 0:33bfb28b0ffc | 1343 | /// Sets the soft current limit for driving in both directions in the Jrk's |
sgrsn | 0:33bfb28b0ffc | 1344 | /// RAM settings, in units of mA. |
sgrsn | 0:33bfb28b0ffc | 1345 | /// |
sgrsn | 0:33bfb28b0ffc | 1346 | /// You would normally configure this setting ahead of time using the Jrk G2 |
sgrsn | 0:33bfb28b0ffc | 1347 | /// Configuration Utility, but this function allows you to change it |
sgrsn | 0:33bfb28b0ffc | 1348 | /// temporarily on the fly. |
sgrsn | 0:33bfb28b0ffc | 1349 | /// |
sgrsn | 0:33bfb28b0ffc | 1350 | /// See also setSoftCurrentLimitForward() and setSoftCurrentLimitReverse(), |
sgrsn | 0:33bfb28b0ffc | 1351 | /// setEncodedHardCurrentLimit(). |
sgrsn | 0:33bfb28b0ffc | 1352 | void setSoftCurrentLimit(uint16_t current) |
sgrsn | 0:33bfb28b0ffc | 1353 | { |
sgrsn | 0:33bfb28b0ffc | 1354 | setRAMSetting16x2(SoftCurrentLimitForward, current, current); |
sgrsn | 0:33bfb28b0ffc | 1355 | } |
sgrsn | 0:33bfb28b0ffc | 1356 | |
sgrsn | 0:33bfb28b0ffc | 1357 | // TODO: add functions to get and set the soft current regulation level |
sgrsn | 0:33bfb28b0ffc | 1358 | |
sgrsn | 0:33bfb28b0ffc | 1359 | ///@} |
sgrsn | 0:33bfb28b0ffc | 1360 | |
sgrsn | 0:33bfb28b0ffc | 1361 | ///\name Low-level settings and variables commands |
sgrsn | 0:33bfb28b0ffc | 1362 | ///@{ |
sgrsn | 0:33bfb28b0ffc | 1363 | |
sgrsn | 0:33bfb28b0ffc | 1364 | /// Gets a contiguous block of settings from the Jrk G2's EEPROM. |
sgrsn | 0:33bfb28b0ffc | 1365 | /// |
sgrsn | 0:33bfb28b0ffc | 1366 | /// The maximum length that can be fetched is 15 bytes. |
sgrsn | 0:33bfb28b0ffc | 1367 | /// |
sgrsn | 0:33bfb28b0ffc | 1368 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 1369 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 1370 | /// // Get the Jrk's serial device number. |
sgrsn | 0:33bfb28b0ffc | 1371 | /// uint8_t deviceNumber; |
sgrsn | 0:33bfb28b0ffc | 1372 | /// jrk.getEEPROMSettings(0x28, 1, &deviceNumber); |
sgrsn | 0:33bfb28b0ffc | 1373 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 1374 | /// |
sgrsn | 0:33bfb28b0ffc | 1375 | /// For information on how the settings are encoded, |
sgrsn | 0:33bfb28b0ffc | 1376 | /// see the Jrk G2 user's guide. |
sgrsn | 0:33bfb28b0ffc | 1377 | void getEEPROMSettings(uint8_t offset, uint8_t length, uint8_t * buffer) |
sgrsn | 0:33bfb28b0ffc | 1378 | { |
sgrsn | 0:33bfb28b0ffc | 1379 | segmentRead(GetEEPROMSettings, offset, length, buffer); |
sgrsn | 0:33bfb28b0ffc | 1380 | } |
sgrsn | 0:33bfb28b0ffc | 1381 | |
sgrsn | 0:33bfb28b0ffc | 1382 | /// Gets a contiguous block of settings from the Jrk G2's RAM. |
sgrsn | 0:33bfb28b0ffc | 1383 | /// |
sgrsn | 0:33bfb28b0ffc | 1384 | /// The maximum length that can be fetched is 15 bytes. |
sgrsn | 0:33bfb28b0ffc | 1385 | /// |
sgrsn | 0:33bfb28b0ffc | 1386 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 1387 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 1388 | /// // Get the Jrk's feedback maximum setting. |
sgrsn | 0:33bfb28b0ffc | 1389 | /// uint8_t buffer[2]; |
sgrsn | 0:33bfb28b0ffc | 1390 | /// jrk.getRAMSettings(0x1F, 2, buffer); |
sgrsn | 0:33bfb28b0ffc | 1391 | /// uint16_t feedbackMaximum = buffer[0] + (buffer[1] << 8); |
sgrsn | 0:33bfb28b0ffc | 1392 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 1393 | /// |
sgrsn | 0:33bfb28b0ffc | 1394 | /// Note that this library has several functions for reading and writing |
sgrsn | 0:33bfb28b0ffc | 1395 | /// specific RAM settings, and they are easier to use than this function. |
sgrsn | 0:33bfb28b0ffc | 1396 | /// |
sgrsn | 0:33bfb28b0ffc | 1397 | /// For information on how the settings are encoded, |
sgrsn | 0:33bfb28b0ffc | 1398 | /// see the Jrk G2 user's guide. |
sgrsn | 0:33bfb28b0ffc | 1399 | void getRAMSettings(uint8_t offset, uint8_t length, uint8_t * buffer) |
sgrsn | 0:33bfb28b0ffc | 1400 | { |
sgrsn | 0:33bfb28b0ffc | 1401 | segmentRead(GetRAMSettings, offset, length, buffer); |
sgrsn | 0:33bfb28b0ffc | 1402 | } |
sgrsn | 0:33bfb28b0ffc | 1403 | |
sgrsn | 0:33bfb28b0ffc | 1404 | /// Sets a contiguous block of settings in the Jrk G2's RAM. |
sgrsn | 0:33bfb28b0ffc | 1405 | /// |
sgrsn | 0:33bfb28b0ffc | 1406 | /// The maximum length that can be written in a single command |
sgrsn | 0:33bfb28b0ffc | 1407 | /// is 7 bytes over Serial, 13 bytes over I2C. |
sgrsn | 0:33bfb28b0ffc | 1408 | /// |
sgrsn | 0:33bfb28b0ffc | 1409 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 1410 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 1411 | /// // Set the Jrk's feedback maximum setting. |
sgrsn | 0:33bfb28b0ffc | 1412 | /// uint16_t feedbackMaximum = 1234; |
sgrsn | 0:33bfb28b0ffc | 1413 | /// uint8_t buffer[2]; |
sgrsn | 0:33bfb28b0ffc | 1414 | /// buffer[0] = feedbackMaximum & 0xFF; |
sgrsn | 0:33bfb28b0ffc | 1415 | /// buffer[1] = feedbackMaximum >> 8 & 0xFF; |
sgrsn | 0:33bfb28b0ffc | 1416 | /// jrk.setRAMSettings(0x1F, 2, buffer); |
sgrsn | 0:33bfb28b0ffc | 1417 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 1418 | /// |
sgrsn | 0:33bfb28b0ffc | 1419 | /// Note that this library has several functions for reading and writing |
sgrsn | 0:33bfb28b0ffc | 1420 | /// specific RAM settings, and they are easier to use than this function. |
sgrsn | 0:33bfb28b0ffc | 1421 | /// |
sgrsn | 0:33bfb28b0ffc | 1422 | /// For information on how the settings are encoded, |
sgrsn | 0:33bfb28b0ffc | 1423 | /// see the Jrk G2 user's guide. |
sgrsn | 0:33bfb28b0ffc | 1424 | void setRAMSettings(uint8_t offset, uint8_t length, uint8_t * buffer) |
sgrsn | 0:33bfb28b0ffc | 1425 | { |
sgrsn | 0:33bfb28b0ffc | 1426 | segmentWrite(SetRAMSettings, offset, length, buffer); |
sgrsn | 0:33bfb28b0ffc | 1427 | } |
sgrsn | 0:33bfb28b0ffc | 1428 | |
sgrsn | 0:33bfb28b0ffc | 1429 | /// Gets a contiguous block of variables from the Jrk G2. |
sgrsn | 0:33bfb28b0ffc | 1430 | /// |
sgrsn | 0:33bfb28b0ffc | 1431 | /// Note that this library has convenient functions for reading every variable |
sgrsn | 0:33bfb28b0ffc | 1432 | /// provided by the Jrk. The main reason to use this function is if you want |
sgrsn | 0:33bfb28b0ffc | 1433 | /// to read multiple variables at once for extra efficiency or to ensure that |
sgrsn | 0:33bfb28b0ffc | 1434 | /// the variables are in a consistent state. |
sgrsn | 0:33bfb28b0ffc | 1435 | /// |
sgrsn | 0:33bfb28b0ffc | 1436 | /// The maximum length that can be fetched is 15 bytes. |
sgrsn | 0:33bfb28b0ffc | 1437 | /// |
sgrsn | 0:33bfb28b0ffc | 1438 | /// Example usage: |
sgrsn | 0:33bfb28b0ffc | 1439 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 1440 | /// // Get the Jrk's last device reset and its up time. |
sgrsn | 0:33bfb28b0ffc | 1441 | /// uint8_t buffer[5]; |
sgrsn | 0:33bfb28b0ffc | 1442 | /// jrk.getVariables(0x1F, 5, buffer); |
sgrsn | 0:33bfb28b0ffc | 1443 | /// ``` |
sgrsn | 0:33bfb28b0ffc | 1444 | /// |
sgrsn | 0:33bfb28b0ffc | 1445 | /// For information on how the variables are encoded, |
sgrsn | 0:33bfb28b0ffc | 1446 | /// see the Jrk G2 user's guide. |
sgrsn | 0:33bfb28b0ffc | 1447 | void getVariables(uint8_t offset, uint8_t length, uint8_t * buffer) |
sgrsn | 0:33bfb28b0ffc | 1448 | { |
sgrsn | 0:33bfb28b0ffc | 1449 | segmentRead(GetVariables, offset, length, buffer); |
sgrsn | 0:33bfb28b0ffc | 1450 | } |
sgrsn | 0:33bfb28b0ffc | 1451 | |
sgrsn | 0:33bfb28b0ffc | 1452 | ///@} |
sgrsn | 0:33bfb28b0ffc | 1453 | |
sgrsn | 0:33bfb28b0ffc | 1454 | protected: |
sgrsn | 0:33bfb28b0ffc | 1455 | /// Zero if the last communication with the device was successful, non-zero |
sgrsn | 0:33bfb28b0ffc | 1456 | /// otherwise. |
sgrsn | 0:33bfb28b0ffc | 1457 | uint8_t _lastError; |
sgrsn | 0:33bfb28b0ffc | 1458 | |
sgrsn | 0:33bfb28b0ffc | 1459 | private: |
sgrsn | 0:33bfb28b0ffc | 1460 | enum VarOffset |
sgrsn | 0:33bfb28b0ffc | 1461 | { |
sgrsn | 0:33bfb28b0ffc | 1462 | Input = 0x00, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1463 | Target = 0x02, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1464 | Feedback = 0x04, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1465 | ScaledFeedback = 0x06, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1466 | Integral = 0x08, // int16_t |
sgrsn | 0:33bfb28b0ffc | 1467 | DutyCycleTarget = 0x0A, // int16_t |
sgrsn | 0:33bfb28b0ffc | 1468 | DutyCycle = 0x0C, // int16_t |
sgrsn | 0:33bfb28b0ffc | 1469 | CurrentLowRes = 0x0E, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1470 | PIDPeriodExceeded = 0x0F, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1471 | PIDPeriodCount = 0x10, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1472 | ErrorFlagsHalting = 0x12, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1473 | ErrorFlagsOccurred = 0x14, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1474 | |
sgrsn | 0:33bfb28b0ffc | 1475 | FlagByte1 = 0x16, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1476 | VinVoltage = 0x17, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1477 | Current = 0x19, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1478 | |
sgrsn | 0:33bfb28b0ffc | 1479 | // variables above can be read with single-byte commands (GetVariable) |
sgrsn | 0:33bfb28b0ffc | 1480 | // variables below must be read with segment read (GetVariables) |
sgrsn | 0:33bfb28b0ffc | 1481 | |
sgrsn | 0:33bfb28b0ffc | 1482 | DeviceReset = 0x1F, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1483 | UpTime = 0x20, // uint32_t |
sgrsn | 0:33bfb28b0ffc | 1484 | RCPulseWidth = 0x24, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1485 | FBTReading = 0x26, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1486 | AnalogReadingSDA = 0x28, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1487 | AnalogReadingFBA = 0x2A, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1488 | DigitalReadings = 0x2C, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1489 | RawCurrent = 0x2D, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1490 | EncodedHardCurrentLimit = 0x2F, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1491 | LastDutyCycle = 0x31, // int16_t |
sgrsn | 0:33bfb28b0ffc | 1492 | CurrentChoppingConsecutiveCount = 0x33, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1493 | CurrentChoppingOccurrenceCount = 0x34, // uint8_t; read with dedicated command |
sgrsn | 0:33bfb28b0ffc | 1494 | }; |
sgrsn | 0:33bfb28b0ffc | 1495 | |
sgrsn | 0:33bfb28b0ffc | 1496 | enum SettingOffset |
sgrsn | 0:33bfb28b0ffc | 1497 | { |
sgrsn | 0:33bfb28b0ffc | 1498 | OptionsByte1 = 0x01, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1499 | OptionsByte2 = 0x02, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1500 | InputMode = 0x03, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1501 | InputErrorMinimum = 0x04, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1502 | InputErrorMaximum = 0x06, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1503 | InputMinimum = 0x08, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1504 | InputMaximum = 0x0A, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1505 | InputNeutralMinimum = 0x0C, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1506 | InputNeutralMaximum = 0x0E, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1507 | OutputMinimum = 0x10, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1508 | OutputNeutral = 0x12, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1509 | OutputMaximum = 0x14, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1510 | InputScalingDegree = 0x16, // uint8_t, |
sgrsn | 0:33bfb28b0ffc | 1511 | InputAnalogSamplesExponent = 0x17, // uint8_t, |
sgrsn | 0:33bfb28b0ffc | 1512 | FeedbackMode = 0x18, // uint8_t, |
sgrsn | 0:33bfb28b0ffc | 1513 | FeedbackErrorMinimum = 0x19, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1514 | FeedbackErrorMaximum = 0x1B, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1515 | FeedbackMinimum = 0x1D, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1516 | FeedbackMaximum = 0x1F, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1517 | FeedbackDeadZone = 0x21, // uint8_t, |
sgrsn | 0:33bfb28b0ffc | 1518 | FeedbackAnalogSamplesExponent = 0x22, // uint8_t, |
sgrsn | 0:33bfb28b0ffc | 1519 | SerialMode = 0x23, // uint8_t, |
sgrsn | 0:33bfb28b0ffc | 1520 | SerialBaudRateGenerator = 0x24, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1521 | SerialTimeout = 0x26, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1522 | SerialDeviceNumber = 0x28, // uint16_t, |
sgrsn | 0:33bfb28b0ffc | 1523 | ErrorEnable = 0x2A, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1524 | ErrorLatch = 0x2C, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1525 | ErrorHard = 0x2E, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1526 | VinCalibration = 0x30, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1527 | PwmFrequency = 0x32, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1528 | CurrentSamplesExponent = 0x33, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1529 | HardOvercurrentThreshold = 0x34, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1530 | CurrentOffsetCalibration = 0x35, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1531 | CurrentScaleCalibration = 0x37, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1532 | FBTMethod = 0x39, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1533 | FBTOptions = 0x3A, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1534 | FBTTimingTimeout = 0x3B, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1535 | FBTSamples = 0x3D, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1536 | FBTDividerExponent = 0x3E, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1537 | IntegralDividerExponent = 0x3F, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1538 | SoftCurrentRegulationLevelForward = 0x40, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1539 | SoftCurrentRegulationLevelReverse = 0x42, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1540 | OptionsByte3 = 0x50, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1541 | ProportionalMultiplier = 0x51, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1542 | ProportionalExponent = 0x53, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1543 | IntegralMultiplier = 0x54, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1544 | IntegralExponent = 0x56, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1545 | DerivativeMultiplier = 0x57, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1546 | DerivativeExponent = 0x59, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1547 | PIDPeriod = 0x5A, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1548 | IntegralLimit = 0x5C, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1549 | MaxDutyCycleWhileFeedbackOutOfRange = 0x5E, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1550 | MaxAccelerationForward = 0x60, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1551 | MaxAccelerationReverse = 0x62, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1552 | MaxDecelerationForward = 0x64, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1553 | MaxDecelerationReverse = 0x66, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1554 | MaxDutyCycleForward = 0x68, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1555 | MaxDutyCycleReverse = 0x6A, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1556 | EncodedHardCurrentLimitForward = 0x6C, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1557 | EncodedHardCurrentLimitReverse = 0x6E, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1558 | BrakeDurationForward = 0x70, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1559 | BrakeDurationReverse = 0x71, // uint8_t |
sgrsn | 0:33bfb28b0ffc | 1560 | SoftCurrentLimitForward = 0x72, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1561 | SoftCurrentLimitReverse = 0x74, // uint16_t |
sgrsn | 0:33bfb28b0ffc | 1562 | }; |
sgrsn | 0:33bfb28b0ffc | 1563 | |
sgrsn | 0:33bfb28b0ffc | 1564 | uint8_t getVar8SingleByte(uint8_t offset) |
sgrsn | 0:33bfb28b0ffc | 1565 | { |
sgrsn | 0:33bfb28b0ffc | 1566 | return commandR8((uint8_t)GetVariable8 | (offset + 1)); |
sgrsn | 0:33bfb28b0ffc | 1567 | } |
sgrsn | 0:33bfb28b0ffc | 1568 | |
sgrsn | 0:33bfb28b0ffc | 1569 | uint16_t getVar16SingleByte(uint8_t offset) |
sgrsn | 0:33bfb28b0ffc | 1570 | { |
sgrsn | 0:33bfb28b0ffc | 1571 | return commandR16((uint8_t)GetVariable16 | (offset + 1)); |
sgrsn | 0:33bfb28b0ffc | 1572 | } |
sgrsn | 0:33bfb28b0ffc | 1573 | |
sgrsn | 0:33bfb28b0ffc | 1574 | uint8_t getVar8(uint8_t offset) |
sgrsn | 0:33bfb28b0ffc | 1575 | { |
sgrsn | 0:33bfb28b0ffc | 1576 | uint8_t result; |
sgrsn | 0:33bfb28b0ffc | 1577 | segmentRead(GetVariables, offset, 1, &result); |
sgrsn | 0:33bfb28b0ffc | 1578 | return result; |
sgrsn | 0:33bfb28b0ffc | 1579 | } |
sgrsn | 0:33bfb28b0ffc | 1580 | |
sgrsn | 0:33bfb28b0ffc | 1581 | uint16_t getVar16(uint8_t offset) |
sgrsn | 0:33bfb28b0ffc | 1582 | { |
sgrsn | 0:33bfb28b0ffc | 1583 | uint8_t buffer[2]; |
sgrsn | 0:33bfb28b0ffc | 1584 | segmentRead(GetVariables, offset, 2, buffer); |
sgrsn | 0:33bfb28b0ffc | 1585 | return ((uint16_t)buffer[0] << 0) | ((uint16_t)buffer[1] << 8); |
sgrsn | 0:33bfb28b0ffc | 1586 | } |
sgrsn | 0:33bfb28b0ffc | 1587 | |
sgrsn | 0:33bfb28b0ffc | 1588 | uint32_t getVar32(uint8_t offset) |
sgrsn | 0:33bfb28b0ffc | 1589 | { |
sgrsn | 0:33bfb28b0ffc | 1590 | uint8_t buffer[4]; |
sgrsn | 0:33bfb28b0ffc | 1591 | segmentRead(GetVariables, offset, 4, buffer); |
sgrsn | 0:33bfb28b0ffc | 1592 | return ((uint32_t)buffer[0] << 0) | |
sgrsn | 0:33bfb28b0ffc | 1593 | ((uint32_t)buffer[1] << 8) | |
sgrsn | 0:33bfb28b0ffc | 1594 | ((uint32_t)buffer[2] << 16) | |
sgrsn | 0:33bfb28b0ffc | 1595 | ((uint32_t)buffer[3] << 24); |
sgrsn | 0:33bfb28b0ffc | 1596 | } |
sgrsn | 0:33bfb28b0ffc | 1597 | |
sgrsn | 0:33bfb28b0ffc | 1598 | void setRAMSetting8(uint8_t offset, uint8_t val) |
sgrsn | 0:33bfb28b0ffc | 1599 | { |
sgrsn | 0:33bfb28b0ffc | 1600 | segmentWrite(SetRAMSettings, offset, 1, &val); |
sgrsn | 0:33bfb28b0ffc | 1601 | } |
sgrsn | 0:33bfb28b0ffc | 1602 | |
sgrsn | 0:33bfb28b0ffc | 1603 | void setRAMSetting16(uint8_t offset, uint16_t val) |
sgrsn | 0:33bfb28b0ffc | 1604 | { |
sgrsn | 0:33bfb28b0ffc | 1605 | uint8_t buffer[2] = {(uint8_t)val, (uint8_t)(val >> 8)}; |
sgrsn | 0:33bfb28b0ffc | 1606 | segmentWrite(SetRAMSettings, offset, 2, buffer); |
sgrsn | 0:33bfb28b0ffc | 1607 | } |
sgrsn | 0:33bfb28b0ffc | 1608 | |
sgrsn | 0:33bfb28b0ffc | 1609 | void setRAMSetting8x2(uint8_t offset, uint8_t val1, uint8_t val2) |
sgrsn | 0:33bfb28b0ffc | 1610 | { |
sgrsn | 0:33bfb28b0ffc | 1611 | uint8_t buffer[2] = {val1, val2}; |
sgrsn | 0:33bfb28b0ffc | 1612 | segmentWrite(SetRAMSettings, offset, 2, buffer); |
sgrsn | 0:33bfb28b0ffc | 1613 | } |
sgrsn | 0:33bfb28b0ffc | 1614 | |
sgrsn | 0:33bfb28b0ffc | 1615 | void setRAMSetting16x2(uint8_t offset, uint16_t val1, uint16_t val2) |
sgrsn | 0:33bfb28b0ffc | 1616 | { |
sgrsn | 0:33bfb28b0ffc | 1617 | uint8_t buffer[4] = {(uint8_t)val1, (uint8_t)(val1 >> 8), |
sgrsn | 0:33bfb28b0ffc | 1618 | (uint8_t)val2, (uint8_t)(val2 >> 8)}; |
sgrsn | 0:33bfb28b0ffc | 1619 | segmentWrite(SetRAMSettings, offset, 4, buffer); |
sgrsn | 0:33bfb28b0ffc | 1620 | } |
sgrsn | 0:33bfb28b0ffc | 1621 | |
sgrsn | 0:33bfb28b0ffc | 1622 | // set multiplier and exponent together in one segment write |
sgrsn | 0:33bfb28b0ffc | 1623 | // (slightly faster than separate calls to getRAMSetting16() and getRAMSetting8()) |
sgrsn | 0:33bfb28b0ffc | 1624 | void setPIDCoefficient(uint8_t offset, uint16_t multiplier, uint8_t exponent) |
sgrsn | 0:33bfb28b0ffc | 1625 | { |
sgrsn | 0:33bfb28b0ffc | 1626 | uint8_t buffer[3] = {(uint8_t)multiplier, (uint8_t)(multiplier >> 8), exponent}; |
sgrsn | 0:33bfb28b0ffc | 1627 | segmentWrite(SetRAMSettings, offset, 3, buffer); |
sgrsn | 0:33bfb28b0ffc | 1628 | } |
sgrsn | 0:33bfb28b0ffc | 1629 | |
sgrsn | 0:33bfb28b0ffc | 1630 | uint8_t getRAMSetting8(uint8_t offset) |
sgrsn | 0:33bfb28b0ffc | 1631 | { |
sgrsn | 0:33bfb28b0ffc | 1632 | uint8_t result; |
sgrsn | 0:33bfb28b0ffc | 1633 | segmentRead(GetRAMSettings, offset, 1, &result); |
sgrsn | 0:33bfb28b0ffc | 1634 | return result; |
sgrsn | 0:33bfb28b0ffc | 1635 | } |
sgrsn | 0:33bfb28b0ffc | 1636 | |
sgrsn | 0:33bfb28b0ffc | 1637 | uint16_t getRAMSetting16(uint8_t offset) |
sgrsn | 0:33bfb28b0ffc | 1638 | { |
sgrsn | 0:33bfb28b0ffc | 1639 | uint8_t buffer[2]; |
sgrsn | 0:33bfb28b0ffc | 1640 | segmentRead(GetRAMSettings, offset, 2, buffer); |
sgrsn | 0:33bfb28b0ffc | 1641 | return ((uint16_t)buffer[0] << 0) | ((uint16_t)buffer[1] << 8); |
sgrsn | 0:33bfb28b0ffc | 1642 | } |
sgrsn | 0:33bfb28b0ffc | 1643 | |
sgrsn | 0:33bfb28b0ffc | 1644 | // Convenience functions that take care of casting a JrkG2Command to a uint8_t. |
sgrsn | 0:33bfb28b0ffc | 1645 | |
sgrsn | 0:33bfb28b0ffc | 1646 | void commandQuick(JrkG2Command cmd) |
sgrsn | 0:33bfb28b0ffc | 1647 | { |
sgrsn | 0:33bfb28b0ffc | 1648 | commandQuick((uint8_t)cmd); |
sgrsn | 0:33bfb28b0ffc | 1649 | } |
sgrsn | 0:33bfb28b0ffc | 1650 | |
sgrsn | 0:33bfb28b0ffc | 1651 | void commandW7(JrkG2Command cmd, uint8_t val) |
sgrsn | 0:33bfb28b0ffc | 1652 | { |
sgrsn | 0:33bfb28b0ffc | 1653 | commandW7((uint8_t)cmd, val); |
sgrsn | 0:33bfb28b0ffc | 1654 | } |
sgrsn | 0:33bfb28b0ffc | 1655 | |
sgrsn | 0:33bfb28b0ffc | 1656 | void commandWs14(JrkG2Command cmd, int16_t val) |
sgrsn | 0:33bfb28b0ffc | 1657 | { |
sgrsn | 0:33bfb28b0ffc | 1658 | commandWs14((uint8_t)cmd, val); |
sgrsn | 0:33bfb28b0ffc | 1659 | } |
sgrsn | 0:33bfb28b0ffc | 1660 | |
sgrsn | 0:33bfb28b0ffc | 1661 | uint8_t commandR8(JrkG2Command cmd) |
sgrsn | 0:33bfb28b0ffc | 1662 | { |
sgrsn | 0:33bfb28b0ffc | 1663 | return commandR8((uint8_t)cmd); |
sgrsn | 0:33bfb28b0ffc | 1664 | } |
sgrsn | 0:33bfb28b0ffc | 1665 | |
sgrsn | 0:33bfb28b0ffc | 1666 | uint16_t commandR16(JrkG2Command cmd) |
sgrsn | 0:33bfb28b0ffc | 1667 | { |
sgrsn | 0:33bfb28b0ffc | 1668 | return commandR16((uint8_t)cmd); |
sgrsn | 0:33bfb28b0ffc | 1669 | } |
sgrsn | 0:33bfb28b0ffc | 1670 | |
sgrsn | 0:33bfb28b0ffc | 1671 | void segmentRead(JrkG2Command cmd, uint8_t offset, |
sgrsn | 0:33bfb28b0ffc | 1672 | uint8_t length, uint8_t * buffer) |
sgrsn | 0:33bfb28b0ffc | 1673 | { |
sgrsn | 0:33bfb28b0ffc | 1674 | segmentRead((uint8_t)cmd, offset, length, buffer); |
sgrsn | 0:33bfb28b0ffc | 1675 | } |
sgrsn | 0:33bfb28b0ffc | 1676 | |
sgrsn | 0:33bfb28b0ffc | 1677 | void segmentWrite(JrkG2Command cmd, uint8_t offset, |
sgrsn | 0:33bfb28b0ffc | 1678 | uint8_t length, uint8_t * buffer) |
sgrsn | 0:33bfb28b0ffc | 1679 | { |
sgrsn | 0:33bfb28b0ffc | 1680 | segmentWrite((uint8_t)cmd, offset, length, buffer); |
sgrsn | 0:33bfb28b0ffc | 1681 | } |
sgrsn | 0:33bfb28b0ffc | 1682 | |
sgrsn | 0:33bfb28b0ffc | 1683 | // Low-level functions implemented by the serial/I2C subclasses. |
sgrsn | 0:33bfb28b0ffc | 1684 | |
sgrsn | 0:33bfb28b0ffc | 1685 | virtual void commandQuick(uint8_t cmd) = 0; |
sgrsn | 0:33bfb28b0ffc | 1686 | virtual void commandW7(uint8_t cmd, uint8_t val) = 0; |
sgrsn | 0:33bfb28b0ffc | 1687 | virtual void commandWs14(uint8_t cmd, int16_t val) = 0; |
sgrsn | 0:33bfb28b0ffc | 1688 | virtual uint8_t commandR8(uint8_t cmd) = 0; |
sgrsn | 0:33bfb28b0ffc | 1689 | virtual uint16_t commandR16(uint8_t cmd) = 0; |
sgrsn | 0:33bfb28b0ffc | 1690 | virtual void segmentRead(uint8_t cmd, uint8_t offset, |
sgrsn | 0:33bfb28b0ffc | 1691 | uint8_t length, uint8_t * buffer) = 0; |
sgrsn | 0:33bfb28b0ffc | 1692 | virtual void segmentWrite(uint8_t cmd, uint8_t offset, |
sgrsn | 0:33bfb28b0ffc | 1693 | uint8_t length, uint8_t * buffer) = 0; |
sgrsn | 0:33bfb28b0ffc | 1694 | }; |
sgrsn | 0:33bfb28b0ffc | 1695 | |
sgrsn | 0:33bfb28b0ffc | 1696 | /// Represents a serial connection to a Jrk G2. |
sgrsn | 0:33bfb28b0ffc | 1697 | /// |
sgrsn | 0:33bfb28b0ffc | 1698 | /// For the high-level commands you can use on this object, see JrkG2Base. |
sgrsn | 2:e78c0ddcf337 | 1699 | class JrkG2Serial : public JrkG2Base |
sgrsn | 0:33bfb28b0ffc | 1700 | { |
sgrsn | 0:33bfb28b0ffc | 1701 | public: |
sgrsn | 2:e78c0ddcf337 | 1702 | JrkG2Serial(AsyncSerial *stream, uint8_t deviceNumber = 255) : |
sgrsn | 0:33bfb28b0ffc | 1703 | _deviceNumber(deviceNumber) |
sgrsn | 0:33bfb28b0ffc | 1704 | { |
sgrsn | 0:33bfb28b0ffc | 1705 | _stream = stream; |
sgrsn | 0:33bfb28b0ffc | 1706 | } |
sgrsn | 0:33bfb28b0ffc | 1707 | |
sgrsn | 0:33bfb28b0ffc | 1708 | /// Gets the serial device number this object is using. |
sgrsn | 0:33bfb28b0ffc | 1709 | uint8_t getDeviceNumber() { return _deviceNumber; } |
sgrsn | 0:33bfb28b0ffc | 1710 | |
sgrsn | 0:33bfb28b0ffc | 1711 | private: |
sgrsn | 2:e78c0ddcf337 | 1712 | //Serial *_stream; |
sgrsn | 2:e78c0ddcf337 | 1713 | AsyncSerial *_stream; |
sgrsn | 2:e78c0ddcf337 | 1714 | |
sgrsn | 0:33bfb28b0ffc | 1715 | const uint8_t _deviceNumber; |
sgrsn | 0:33bfb28b0ffc | 1716 | |
sgrsn | 0:33bfb28b0ffc | 1717 | virtual void commandQuick(uint8_t cmd) { sendCommandHeader(cmd); } |
sgrsn | 0:33bfb28b0ffc | 1718 | virtual void commandW7(uint8_t cmd, uint8_t val); |
sgrsn | 0:33bfb28b0ffc | 1719 | virtual void commandWs14(uint8_t cmd, int16_t val); |
sgrsn | 0:33bfb28b0ffc | 1720 | virtual uint8_t commandR8(uint8_t cmd); |
sgrsn | 0:33bfb28b0ffc | 1721 | virtual uint16_t commandR16(uint8_t cmd); |
sgrsn | 0:33bfb28b0ffc | 1722 | virtual void segmentRead(uint8_t cmd, uint8_t offset, |
sgrsn | 0:33bfb28b0ffc | 1723 | uint8_t length, uint8_t * buffer); |
sgrsn | 0:33bfb28b0ffc | 1724 | virtual void segmentWrite(uint8_t cmd, uint8_t offset, |
sgrsn | 0:33bfb28b0ffc | 1725 | uint8_t length, uint8_t * buffer); |
sgrsn | 0:33bfb28b0ffc | 1726 | |
sgrsn | 0:33bfb28b0ffc | 1727 | void sendCommandHeader(uint8_t cmd); |
sgrsn | 0:33bfb28b0ffc | 1728 | void serialW7(uint8_t val) { _stream->putc(val & 0x7F); } |
sgrsn | 0:33bfb28b0ffc | 1729 | }; |
sgrsn | 0:33bfb28b0ffc | 1730 | |
sgrsn | 0:33bfb28b0ffc | 1731 | /// Represents an I2C connection to a Jrk G2. |
sgrsn | 0:33bfb28b0ffc | 1732 | /// |
sgrsn | 0:33bfb28b0ffc | 1733 | /// For the high-level commands you can use on this object, see JrkG2Base. |
sgrsn | 0:33bfb28b0ffc | 1734 | class JrkG2I2C : public JrkG2Base |
sgrsn | 0:33bfb28b0ffc | 1735 | { |
sgrsn | 0:33bfb28b0ffc | 1736 | public: |
sgrsn | 0:33bfb28b0ffc | 1737 | JrkG2I2C(I2C *i2c, uint8_t address = 11) : _address((address & 0x7F) << 1) |
sgrsn | 0:33bfb28b0ffc | 1738 | { |
sgrsn | 0:33bfb28b0ffc | 1739 | _i2c = i2c; |
sgrsn | 0:33bfb28b0ffc | 1740 | } |
sgrsn | 0:33bfb28b0ffc | 1741 | |
sgrsn | 0:33bfb28b0ffc | 1742 | /// Gets the I2C address this object is using. |
sgrsn | 0:33bfb28b0ffc | 1743 | uint8_t getAddress() { return _address; } |
sgrsn | 0:33bfb28b0ffc | 1744 | |
sgrsn | 0:33bfb28b0ffc | 1745 | private: |
sgrsn | 0:33bfb28b0ffc | 1746 | I2C *_i2c; |
sgrsn | 0:33bfb28b0ffc | 1747 | const uint8_t _address; |
sgrsn | 0:33bfb28b0ffc | 1748 | |
sgrsn | 0:33bfb28b0ffc | 1749 | virtual void commandQuick(uint8_t cmd); |
sgrsn | 0:33bfb28b0ffc | 1750 | virtual void commandW7(uint8_t cmd, uint8_t val); |
sgrsn | 0:33bfb28b0ffc | 1751 | virtual void commandWs14(uint8_t cmd, int16_t val); |
sgrsn | 0:33bfb28b0ffc | 1752 | virtual uint8_t commandR8(uint8_t cmd); |
sgrsn | 0:33bfb28b0ffc | 1753 | virtual uint16_t commandR16(uint8_t cmd); |
sgrsn | 0:33bfb28b0ffc | 1754 | virtual void segmentRead(uint8_t cmd, uint8_t offset, |
sgrsn | 0:33bfb28b0ffc | 1755 | uint8_t length, uint8_t * buffer); |
sgrsn | 0:33bfb28b0ffc | 1756 | virtual void segmentWrite(uint8_t cmd, uint8_t offset, |
sgrsn | 0:33bfb28b0ffc | 1757 | uint8_t length, uint8_t * buffer) ; |
sgrsn | 0:33bfb28b0ffc | 1758 | }; |