Martijn Grootens / AS5048

Library for SPI communication with the AMS AS5048 rotary sensor

Dependents:   heros_leg_readout_torque_addition heros_leg_readout_torque_addition heros_leg_readout_torque_addition_V3

As5048.h@3:579e12eda4e6, 2016-08-23 (annotated)

Committer:
megrootens
Date:
Tue Aug 23 15:09:35 2016 +0000
Revision:
3:579e12eda4e6
Parent:
2:111641f7e672
Child:
4:56d59ce73270
moved const values outside class to static const within class; move enums that define commands within class

Who changed what in which revision?

UserRevisionLine numberNew contents of line
megrootens 0:723d48642d5c 1 #ifndef _AS5048_H_
megrootens 0:723d48642d5c 2 #define _AS5048_H_
megrootens 0:723d48642d5c 3
megrootens 0:723d48642d5c 4 #include "mbed.h"
megrootens 0:723d48642d5c 5 /**
megrootens 0:723d48642d5c 6 * Interfacing with the AMS AS5048A magnetic rotary sensor using SPI protocol
megrootens 0:723d48642d5c 7 * AS5048 uses 16-bit transfer;
megrootens 0:723d48642d5c 8 * We use two 8-bit transfers for compatibility with 8-bit SPI master devices
megrootens 0:723d48642d5c 9 * SPI protocol:
megrootens 0:723d48642d5c 10 * Mode = 1:
megrootens 0:723d48642d5c 11 * clock polarity = 0 --> clock pulse is high
megrootens 0:723d48642d5c 12 * clock phase = 1 --> sample on falling edge of clock pulse
megrootens 0:723d48642d5c 13 * Code was succesfully tested on the FRDM KL25Z and K22F. The same code fails
megrootens 0:723d48642d5c 14 * on the K64F for some reason. Sampling using a logic analyzer does however
megrootens 0:723d48642d5c 15 * show the same results for al three boards.
megrootens 0:723d48642d5c 16 */
megrootens 0:723d48642d5c 17 class As5048 {
megrootens 0:723d48642d5c 18
megrootens 3:579e12eda4e6 19
megrootens 0:723d48642d5c 20 public:
megrootens 0:723d48642d5c 21
megrootens 3:579e12eda4e6 22 // AS5048 flags
megrootens 3:579e12eda4e6 23 typedef enum {
megrootens 3:579e12eda4e6 24 AS_FLAG_PARITY = 0x8000,
megrootens 3:579e12eda4e6 25 AS_FLAG_READ = 0x4000,
megrootens 3:579e12eda4e6 26 } As5048Flag;
megrootens 3:579e12eda4e6 27
megrootens 3:579e12eda4e6 28 // AS5048 commands
megrootens 3:579e12eda4e6 29 typedef enum {
megrootens 3:579e12eda4e6 30 AS_CMD_NOP = 0x0000,
megrootens 3:579e12eda4e6 31 AS_CMD_ERROR = 0x0001 | AS_FLAG_READ, // Reads error register of sensor and clear error flags
megrootens 3:579e12eda4e6 32 AS_CMD_DIAGNOSTICS = 0x3FFD | AS_FLAG_READ, // Reads automatic gain control and diagnostics info
megrootens 3:579e12eda4e6 33 AS_CMD_MAGNITUDE = 0x3FFE | AS_FLAG_READ,
megrootens 3:579e12eda4e6 34 AS_CMD_ANGLE = 0x3FFF | AS_FLAG_PARITY | AS_FLAG_READ,
megrootens 3:579e12eda4e6 35 } As5048Command;
megrootens 3:579e12eda4e6 36
megrootens 3:579e12eda4e6 37 // AS5048 diagnostics
megrootens 3:579e12eda4e6 38 typedef enum {
megrootens 3:579e12eda4e6 39 AS_DIAG_CORDIC_OVERFLOW = 0x0200,
megrootens 3:579e12eda4e6 40 AS_DIAG_HIGH_MAGNETIC = 0x0400,
megrootens 3:579e12eda4e6 41 AS_DIAG_LOW_MAGNETIC = 0x0800,
megrootens 3:579e12eda4e6 42 } As5048Diagnostics;
megrootens 3:579e12eda4e6 43
megrootens 0:723d48642d5c 44 /**
megrootens 0:723d48642d5c 45 * Creates an object of num_sensors daisy chained AS5048 sensors;
megrootens 0:723d48642d5c 46 * default number of sensors in chain is 1
megrootens 0:723d48642d5c 47 * @param mosi: pinname of the mosi pin of the spi communication
megrootens 0:723d48642d5c 48 * @param miso: pinname of the miso pin of the spi communication
megrootens 0:723d48642d5c 49 * @param sck: pinname of the clock pin of the spi communication
megrootens 0:723d48642d5c 50 * @param cs: pinname of the chip select pin of the spi communication
megrootens 0:723d48642d5c 51 * @param num_sensors = 1: number of sensors in daisy chain
megrootens 0:723d48642d5c 52 */
megrootens 0:723d48642d5c 53 As5048(PinName mosi, PinName miso, PinName sck, PinName cs, int num_sensors = 1):
megrootens 0:723d48642d5c 54 kNumSensors_(num_sensors),
megrootens 0:723d48642d5c 55 chip_(cs),
megrootens 0:723d48642d5c 56 spi_(mosi, miso, sck)
megrootens 0:723d48642d5c 57 {
megrootens 0:723d48642d5c 58 DeselectChip();
megrootens 0:723d48642d5c 59
megrootens 0:723d48642d5c 60 spi_.format(kSpiBitsPerTransfer, kSpiMode);
megrootens 0:723d48642d5c 61 spi_.frequency(kSpiFrequency);
megrootens 0:723d48642d5c 62
megrootens 0:723d48642d5c 63 read_buffer_ = new uint16_t[kNumSensors_];
megrootens 0:723d48642d5c 64 angle_buffer_ = new uint16_t[kNumSensors_];
megrootens 0:723d48642d5c 65 angle_offset_ = new uint16_t[kNumSensors_];
megrootens 1:94b48453d13a 66 directions_ = new bool[kNumSensors_];
megrootens 0:723d48642d5c 67
megrootens 0:723d48642d5c 68 for (int i=0; i<kNumSensors_; ++i) {
megrootens 0:723d48642d5c 69 read_buffer_[i] = 0;
megrootens 0:723d48642d5c 70 angle_buffer_[i] = 0;
megrootens 0:723d48642d5c 71 angle_offset_[i] = 0;
megrootens 1:94b48453d13a 72 directions_[i] = true;
megrootens 0:723d48642d5c 73 }
megrootens 0:723d48642d5c 74
megrootens 0:723d48642d5c 75 last_command_ = AS_CMD_NOP;
megrootens 0:723d48642d5c 76 }
megrootens 0:723d48642d5c 77
megrootens 0:723d48642d5c 78
megrootens 0:723d48642d5c 79 /**
megrootens 0:723d48642d5c 80 * Destructor, memory deallocation
megrootens 0:723d48642d5c 81 */
megrootens 2:111641f7e672 82 ~As5048()
megrootens 2:111641f7e672 83 {
megrootens 0:723d48642d5c 84 delete [] read_buffer_;
megrootens 0:723d48642d5c 85 delete [] angle_buffer_;
megrootens 0:723d48642d5c 86 delete [] angle_offset_;
megrootens 1:94b48453d13a 87 delete [] directions_;
megrootens 0:723d48642d5c 88 }
megrootens 0:723d48642d5c 89
megrootens 0:723d48642d5c 90 /**
megrootens 0:723d48642d5c 91 * Parity check
megrootens 0:723d48642d5c 92 * @param n: integer to check
megrootens 0:723d48642d5c 93 * @return: true if ok
megrootens 0:723d48642d5c 94 */
megrootens 2:111641f7e672 95 static bool CheckParity(int n)
megrootens 2:111641f7e672 96 {
megrootens 0:723d48642d5c 97 int parity = n;
megrootens 0:723d48642d5c 98 for(int i=1; i <= kNumSensorBits+1; ++i) {
megrootens 0:723d48642d5c 99 n >>= 1;
megrootens 0:723d48642d5c 100 parity ^= n;
megrootens 0:723d48642d5c 101 }
megrootens 0:723d48642d5c 102 return (parity & kParity) == 0;
megrootens 0:723d48642d5c 103 }
megrootens 0:723d48642d5c 104
megrootens 0:723d48642d5c 105 /**
megrootens 0:723d48642d5c 106 * Update the buffer with angular measurements
megrootens 0:723d48642d5c 107 * NOTE 1:
megrootens 0:723d48642d5c 108 * If the last command sent through Transfer was *not* AS_CMD_ANGLE
megrootens 0:723d48642d5c 109 * then we need an additional Transfer; this takes more time!
megrootens 0:723d48642d5c 110 * This should not occur, since Transfer is not *yet* used elsewhere.
megrootens 0:723d48642d5c 111 * NOTE 2:
megrootens 0:723d48642d5c 112 * We run a parity check on the results from the transfer. We only
megrootens 0:723d48642d5c 113 * update the angle_buffer_ with values that pass the parity check.
megrootens 0:723d48642d5c 114 * Measurement using Timer on K64F for last_command_ == AS_CMD_ANGLE
megrootens 0:723d48642d5c 115 * shows this function takes 87 or 88 us.
megrootens 0:723d48642d5c 116 */
megrootens 2:111641f7e672 117 void UpdateAngleBuffer()
megrootens 2:111641f7e672 118 {
megrootens 0:723d48642d5c 119 // ensure that the new results indeed will be angles
megrootens 0:723d48642d5c 120 if (last_command_ != AS_CMD_ANGLE) {
megrootens 0:723d48642d5c 121 Transfer(AS_CMD_ANGLE);
megrootens 0:723d48642d5c 122 }
megrootens 0:723d48642d5c 123
megrootens 0:723d48642d5c 124 // update the read buffer
megrootens 0:723d48642d5c 125 Transfer(AS_CMD_ANGLE);
megrootens 0:723d48642d5c 126
megrootens 0:723d48642d5c 127 // update the angle buffer with parity checked values
megrootens 0:723d48642d5c 128 for (int i=0; i<kNumSensors_; ++i) {
megrootens 0:723d48642d5c 129 if (CheckParity(read_buffer_[i])) {
megrootens 0:723d48642d5c 130 // only update angles when parity is correct
megrootens 0:723d48642d5c 131 angle_buffer_[i] = read_buffer_[i];
megrootens 0:723d48642d5c 132 }
megrootens 0:723d48642d5c 133 }
megrootens 0:723d48642d5c 134 }
megrootens 0:723d48642d5c 135
megrootens 0:723d48642d5c 136 /**
megrootens 0:723d48642d5c 137 * @return: pointer to read_buffer_
megrootens 0:723d48642d5c 138 */
megrootens 0:723d48642d5c 139 const uint16_t* get_read_buffer() { return read_buffer_; }
megrootens 0:723d48642d5c 140
megrootens 0:723d48642d5c 141 /**
megrootens 0:723d48642d5c 142 * @return: pointer to angle_buffer_
megrootens 0:723d48642d5c 143 */
megrootens 0:723d48642d5c 144 const uint16_t* get_angle_buffer() { return angle_buffer_; }
megrootens 0:723d48642d5c 145
megrootens 0:723d48642d5c 146 /**
megrootens 0:723d48642d5c 147 * @return: pointer to angle_offet_
megrootens 0:723d48642d5c 148 */
megrootens 0:723d48642d5c 149 const uint16_t* get_angle_offset() { return angle_offset_; }
megrootens 0:723d48642d5c 150
megrootens 0:723d48642d5c 151 /**
megrootens 1:94b48453d13a 152 * @return: pointer to directions_
megrootens 1:94b48453d13a 153 */
megrootens 1:94b48453d13a 154 const bool * get_directions_() { return directions_;}
megrootens 1:94b48453d13a 155
megrootens 1:94b48453d13a 156 /**
megrootens 0:723d48642d5c 157 * You get the angles from two UpdateAngleBuffer() calls before
megrootens 0:723d48642d5c 158 * @return: 14 bits absolute position
megrootens 0:723d48642d5c 159 */
megrootens 2:111641f7e672 160 int getAngle(int i_sensor=0)
megrootens 2:111641f7e672 161 {
megrootens 1:94b48453d13a 162 int ans = ((int) (angle_buffer_[i_sensor] & kMask)) - angle_offset_[i_sensor];
megrootens 1:94b48453d13a 163 return directions_[i_sensor]?ans:-ans;
megrootens 0:723d48642d5c 164 }
megrootens 0:723d48642d5c 165
megrootens 0:723d48642d5c 166 /**
megrootens 0:723d48642d5c 167 * You get the angles from two UpdateAngleBuffer() calls before
megrootens 0:723d48642d5c 168 * @return: revolution ratio in [0,1]
megrootens 0:723d48642d5c 169 */
megrootens 0:723d48642d5c 170 float getAngleRatio(int i_sensor=0) { return (float) getAngle(i_sensor) / kCountsPerRev; }
megrootens 0:723d48642d5c 171
megrootens 0:723d48642d5c 172 /**
megrootens 0:723d48642d5c 173 * You get the angles from two UpdateAngleBuffer() calls before
megrootens 0:723d48642d5c 174 * @return: angle in degrees
megrootens 0:723d48642d5c 175 */
megrootens 0:723d48642d5c 176 float getAngleDegrees(int i_sensor=0) { return getAngleRatio(i_sensor) * kDegPerRev; }
megrootens 0:723d48642d5c 177
megrootens 0:723d48642d5c 178 /**
megrootens 0:723d48642d5c 179 * You get the angles from two UpdateAngleBuffer() calls before
megrootens 0:723d48642d5c 180 * @return: angle in radians
megrootens 0:723d48642d5c 181 */
megrootens 0:723d48642d5c 182 float getAngleRadians(int i_sensor=0) { return getAngleRatio(i_sensor) * kRadPerRev; }
megrootens 0:723d48642d5c 183
megrootens 0:723d48642d5c 184 /**
megrootens 1:94b48453d13a 185 * Set direction for a sensor
megrootens 1:94b48453d13a 186 * @param i_sensor: id of sensor for which the offset is to be set
megrootens 1:94b48453d13a 187 * @param dir: true positive, false negative
megrootens 1:94b48453d13a 188 * @return: true if i_sensor in [0,kNumSensor_)
megrootens 1:94b48453d13a 189 */
megrootens 2:111641f7e672 190 bool setDirection(int i_sensor, bool dir)
megrootens 2:111641f7e672 191 {
megrootens 1:94b48453d13a 192 if (i_sensor>-1 and i_sensor<kNumSensors_) {
megrootens 1:94b48453d13a 193 directions_[i_sensor] = dir;
megrootens 1:94b48453d13a 194 return true;
megrootens 1:94b48453d13a 195 }
megrootens 1:94b48453d13a 196 return false;
megrootens 1:94b48453d13a 197 }
megrootens 1:94b48453d13a 198
megrootens 1:94b48453d13a 199 /**
megrootens 1:94b48453d13a 200 * Set direction for the first sensor
megrootens 1:94b48453d13a 201 * @param dir: true positive, false negative
megrootens 1:94b48453d13a 202 * @return: true if i_sensor in [0,kNumSensor_)
megrootens 1:94b48453d13a 203 */
megrootens 2:111641f7e672 204 bool setDirection(bool dir)
megrootens 2:111641f7e672 205 {
megrootens 1:94b48453d13a 206 return setDirection(0,dir);
megrootens 1:94b48453d13a 207 }
megrootens 1:94b48453d13a 208
megrootens 1:94b48453d13a 209
megrootens 1:94b48453d13a 210 /**
megrootens 0:723d48642d5c 211 * Set offset for a sensor
megrootens 0:723d48642d5c 212 * @param i_sensor: id of sensor for which the offset is to be set
megrootens 0:723d48642d5c 213 * @param offset: offset in counts [0,2**14-1]
megrootens 0:723d48642d5c 214 * @return: true if i_sensor in [0,kNumSensor_)
megrootens 0:723d48642d5c 215 */
megrootens 2:111641f7e672 216 bool setOffset(int i_sensor, uint16_t offset)
megrootens 2:111641f7e672 217 {
megrootens 0:723d48642d5c 218 if (i_sensor>-1 and i_sensor<kNumSensors_) {
megrootens 0:723d48642d5c 219 angle_offset_[i_sensor] = offset;
megrootens 0:723d48642d5c 220 return true;
megrootens 0:723d48642d5c 221 }
megrootens 0:723d48642d5c 222 return false;
megrootens 0:723d48642d5c 223 }
megrootens 0:723d48642d5c 224
megrootens 0:723d48642d5c 225 /**
megrootens 0:723d48642d5c 226 * Set offset for the first sensor
megrootens 0:723d48642d5c 227 * @param offset: offset in counts [0,2**14-1]
megrootens 0:723d48642d5c 228 * @return: true if i_sensor in [0,kNumSensor_)
megrootens 0:723d48642d5c 229 */
megrootens 0:723d48642d5c 230 bool setOffset(uint16_t offset) { return setOffset(0,offset); }
megrootens 0:723d48642d5c 231
megrootens 0:723d48642d5c 232 /**
megrootens 0:723d48642d5c 233 * Set offset for a sensor
megrootens 0:723d48642d5c 234 * @param i_sensor: id of sensor for which the offset is to be set
megrootens 0:723d48642d5c 235 * @param offset_ratio: offset in ratio in [0,1]
megrootens 0:723d48642d5c 236 * @return: true if i_sensor in [0,kNumSensor_)
megrootens 0:723d48642d5c 237 */
megrootens 2:111641f7e672 238 bool setOffsetRatio (int i_sensor, float offset_ratio)
megrootens 2:111641f7e672 239 {
megrootens 0:723d48642d5c 240 return setOffset(i_sensor,offset_ratio*kCountsPerRev);
megrootens 0:723d48642d5c 241 }
megrootens 0:723d48642d5c 242
megrootens 0:723d48642d5c 243 /**
megrootens 0:723d48642d5c 244 * Set offset for the first sensor
megrootens 0:723d48642d5c 245 * @param offset_ratio: offset in ratio in [0,1]
megrootens 0:723d48642d5c 246 * @return: true if i_sensor in [0,kNumSensor_)
megrootens 0:723d48642d5c 247 */
megrootens 2:111641f7e672 248 bool setOffsetRatio(float offset_ratio)
megrootens 2:111641f7e672 249 {
megrootens 0:723d48642d5c 250 return setOffsetRatio(0,offset_ratio);
megrootens 0:723d48642d5c 251 }
megrootens 0:723d48642d5c 252
megrootens 0:723d48642d5c 253 /**
megrootens 0:723d48642d5c 254 * Set offset for a sensor
megrootens 0:723d48642d5c 255 * @param i_sensor: id of sensor for which the offset is to be set
megrootens 0:723d48642d5c 256 * @param offset_degrees: offset in degrees in [0,360]
megrootens 0:723d48642d5c 257 * @return: true if i_sensor in [0,kNumSensor_)
megrootens 0:723d48642d5c 258 */
megrootens 2:111641f7e672 259 bool setOffsetDegrees(int i_sensor, float offset_degrees)
megrootens 2:111641f7e672 260 {
megrootens 0:723d48642d5c 261 return setOffsetRatio(i_sensor,offset_degrees / kDegPerRev);
megrootens 0:723d48642d5c 262 }
megrootens 0:723d48642d5c 263
megrootens 0:723d48642d5c 264 /**
megrootens 0:723d48642d5c 265 * Set offset for the first sensor
megrootens 0:723d48642d5c 266 * @param offset_degrees: offset in degrees in [0,360]
megrootens 0:723d48642d5c 267 * @return: true if i_sensor in [0,kNumSensor_)
megrootens 0:723d48642d5c 268 */
megrootens 2:111641f7e672 269 bool setOffsetDegrees(float offset_degrees)
megrootens 2:111641f7e672 270 {
megrootens 0:723d48642d5c 271 return setOffsetDegrees(0, offset_degrees);
megrootens 0:723d48642d5c 272 }
megrootens 0:723d48642d5c 273
megrootens 0:723d48642d5c 274 /**
megrootens 0:723d48642d5c 275 * Set offset for a sensor
megrootens 0:723d48642d5c 276 * @param i_sensor: id of sensor for which the offset is to be set
megrootens 0:723d48642d5c 277 * @param offset_radians: offset in radians in [0,2*pi]
megrootens 0:723d48642d5c 278 * @return: true if i_sensor in [0,kNumSensor_)
megrootens 0:723d48642d5c 279 */
megrootens 2:111641f7e672 280 bool setOffsetRadians(int i_sensor, float offset_radians)
megrootens 2:111641f7e672 281 {
megrootens 0:723d48642d5c 282 return setOffsetRatio(i_sensor, offset_radians / kRadPerRev);
megrootens 0:723d48642d5c 283 }
megrootens 0:723d48642d5c 284
megrootens 0:723d48642d5c 285 /**
megrootens 0:723d48642d5c 286 * Set offset for the first sensor
megrootens 0:723d48642d5c 287 * @param offset_radians: offset in radians in [0,2*pi]
megrootens 0:723d48642d5c 288 * @return: true if i_sensor in [0,kNumSensor_)
megrootens 0:723d48642d5c 289 */
megrootens 2:111641f7e672 290 bool setOffsetRadians(float offset_radians)
megrootens 2:111641f7e672 291 {
megrootens 0:723d48642d5c 292 return setOffsetRadians(0, offset_radians);
megrootens 0:723d48642d5c 293 }
megrootens 1:94b48453d13a 294
megrootens 1:94b48453d13a 295
megrootens 0:723d48642d5c 296
megrootens 0:723d48642d5c 297
megrootens 0:723d48642d5c 298 protected:
megrootens 0:723d48642d5c 299
megrootens 3:579e12eda4e6 300 static const int kNumSensorBits = 14; // 14-bits sensor
megrootens 3:579e12eda4e6 301 static const uint16_t kCountsPerRev = 0x4000; // 2**NUM_SENSOR_BITS
megrootens 3:579e12eda4e6 302 static const uint16_t kMask = 0x3FFF; // 2**NUM_SENSOR_BITS - 1
megrootens 3:579e12eda4e6 303 static const int kParity = 1; // even parity
megrootens 3:579e12eda4e6 304
megrootens 3:579e12eda4e6 305 static const int kSpiFrequency = 1000000; // AS5048 max 10 MHz
megrootens 3:579e12eda4e6 306 static const int kSpiBitsPerTransfer = 8;
megrootens 3:579e12eda4e6 307 static const int kSpiMode = 1;
megrootens 3:579e12eda4e6 308
megrootens 3:579e12eda4e6 309 static const float kDegPerRev = 360.0f; // 360 degrees/rev
megrootens 3:579e12eda4e6 310 static const float kRadPerRev = 6.28318530718f; // 2*pi rad/rev
megrootens 3:579e12eda4e6 311
megrootens 0:723d48642d5c 312 /**
megrootens 0:723d48642d5c 313 * Select (low) chip, and wait 1 us (at least 350 ns)
megrootens 0:723d48642d5c 314 */
megrootens 0:723d48642d5c 315 void SelectChip() { chip_.write(0); wait_us(1); }
megrootens 0:723d48642d5c 316
megrootens 0:723d48642d5c 317 /**
megrootens 0:723d48642d5c 318 * Deselect (high) chip, and wait 1 us (at least 350 ns)
megrootens 0:723d48642d5c 319 */
megrootens 0:723d48642d5c 320 void DeselectChip() { chip_.write(1); wait_us(1); }
megrootens 0:723d48642d5c 321
megrootens 0:723d48642d5c 322 /**
megrootens 0:723d48642d5c 323 * SPI transfer between each of the daisy chained sensors
megrootens 0:723d48642d5c 324 * @param cmd: Command to send
megrootens 0:723d48642d5c 325 */
megrootens 2:111641f7e672 326 void Transfer(As5048Command cmd)
megrootens 2:111641f7e672 327 {
megrootens 0:723d48642d5c 328 SelectChip();
megrootens 0:723d48642d5c 329 for(int i=0; i<kNumSensors_; ++i){
megrootens 0:723d48642d5c 330 read_buffer_[i] = spi_.write(cmd>>8) << 8;
megrootens 0:723d48642d5c 331 read_buffer_[i] |= spi_.write(cmd & 0x00FF);
megrootens 0:723d48642d5c 332 }
megrootens 0:723d48642d5c 333 DeselectChip();
megrootens 0:723d48642d5c 334 last_command_ = cmd;
megrootens 0:723d48642d5c 335 }
megrootens 0:723d48642d5c 336
megrootens 0:723d48642d5c 337 const int kNumSensors_; // number of sensors in daisy chain
megrootens 0:723d48642d5c 338 DigitalOut chip_; // chip select port
megrootens 0:723d48642d5c 339 SPI spi_; // mbed spi communiation object
megrootens 0:723d48642d5c 340
megrootens 0:723d48642d5c 341 uint16_t* read_buffer_; // buffer for results from last transfer
megrootens 0:723d48642d5c 342 uint16_t* angle_buffer_; // buffer for angle results from last transfer
megrootens 0:723d48642d5c 343 uint16_t* angle_offset_; // offset array for each sensor
megrootens 1:94b48453d13a 344 bool* directions_; // direction true positive, false negative
megrootens 0:723d48642d5c 345
megrootens 0:723d48642d5c 346 As5048Command last_command_;// command sent during last Transfer
megrootens 0:723d48642d5c 347
megrootens 0:723d48642d5c 348 };
megrootens 0:723d48642d5c 349 #endif