Statistics
| Branch: | Revision:

adafruit_bno055 / Adafruit_BNO055.cpp @ 5dd991c7

History | View | Annotate | Download (26.09 KB)

1
/*!
2
 * @file Adafruit_BNO055.cpp
3
 *
4
 *  @mainpage Adafruit BNO055 Orientation Sensor
5
 *
6
 *  @section intro_sec Introduction
7
 *
8
 *  This is a library for the BNO055 orientation sensor
9
 *
10
 *  Designed specifically to work with the Adafruit BNO055 Breakout.
11
 *
12
 *  Pick one up today in the adafruit shop!
13
 *  ------> https://www.adafruit.com/product/2472
14
 *
15
 *  These sensors use I2C to communicate, 2 pins are required to interface.
16
 *
17
 *  Adafruit invests time and resources providing this open source code,
18
 *  please support Adafruit andopen-source hardware by purchasing products
19
 *  from Adafruit!
20
 *
21
 *  @section author Author
22
 *
23
 *  K.Townsend (Adafruit Industries)
24
 *
25
 *  @section license License
26
 *
27
 *  MIT license, all text above must be included in any redistribution
28
 */
29

    
30
#include "Arduino.h"
31

    
32
#include <limits.h>
33
#include <math.h>
34

    
35
#include "Adafruit_BNO055.h"
36

    
37
/*!
38
 *  @brief  Instantiates a new Adafruit_BNO055 class
39
 *  @param  sensorID
40
 *          sensor ID
41
 *  @param  address
42
 *          i2c address
43
 *  @param  theWire
44
 *          Wire object
45
 */
46
Adafruit_BNO055::Adafruit_BNO055(int32_t sensorID, uint8_t address,
47
                                 TwoWire *theWire) {
48
  _sensorID = sensorID;
49
  _address = address;
50
  _wire = theWire;
51
}
52

    
53
/*!
54
 *  @brief  Sets up the HW
55
 *  @param  mode
56
 *          mode values
57
 *           [OPERATION_MODE_CONFIG,
58
 *            OPERATION_MODE_ACCONLY,
59
 *            OPERATION_MODE_MAGONLY,
60
 *            OPERATION_MODE_GYRONLY,
61
 *            OPERATION_MODE_ACCMAG,
62
 *            OPERATION_MODE_ACCGYRO,
63
 *            OPERATION_MODE_MAGGYRO,
64
 *            OPERATION_MODE_AMG,
65
 *            OPERATION_MODE_IMUPLUS,
66
 *            OPERATION_MODE_COMPASS,
67
 *            OPERATION_MODE_M4G,
68
 *            OPERATION_MODE_NDOF_FMC_OFF,
69
 *            OPERATION_MODE_NDOF]
70
 *  @return true if process is successful
71
 */
72
bool Adafruit_BNO055::begin(adafruit_bno055_opmode_t mode) {
73
#if defined(ARDUINO_SAMD_ZERO) && (_address == BNO055_ADDRESS_A)
74
#error                                                                         \
75
    "On an arduino Zero, BNO055's ADR pin must be high. Fix that, then delete this line."
76
  _address = BNO055_ADDRESS_B;
77
#endif
78

    
79
  /* Enable I2C */
80
  _wire->begin();
81

    
82
  // BNO055 clock stretches for 500us or more!
83
#ifdef ESP8266
84
  _wire->setClockStretchLimit(1000); // Allow for 1000us of clock stretching
85
#endif
86

    
87
  /* Make sure we have the right device */
88
  uint8_t id = read8(BNO055_CHIP_ID_ADDR);
89
  if (id != BNO055_ID) {
90
    delay(1000); // hold on for boot
91
    id = read8(BNO055_CHIP_ID_ADDR);
92
    if (id != BNO055_ID) {
93
      return false; // still not? ok bail
94
    }
95
  }
96

    
97
  /* Switch to config mode (just in case since this is the default) */
98
  setMode(OPERATION_MODE_CONFIG);
99

    
100
  /* Reset */
101
  write8(BNO055_SYS_TRIGGER_ADDR, 0x20);
102
  /* Delay incrased to 30ms due to power issues https://tinyurl.com/y375z699 */
103
  delay(30);
104
  while (read8(BNO055_CHIP_ID_ADDR) != BNO055_ID) {
105
    delay(10);
106
  }
107
  delay(50);
108

    
109
  /* Set to normal power mode */
110
  write8(BNO055_PWR_MODE_ADDR, POWER_MODE_NORMAL);
111
  delay(10);
112

    
113
  write8(BNO055_PAGE_ID_ADDR, 0);
114

    
115
  /* Set the output units */
116
  /*
117
  uint8_t unitsel = (0 << 7) | // Orientation = Android
118
                    (0 << 4) | // Temperature = Celsius
119
                    (0 << 2) | // Euler = Degrees
120
                    (1 << 1) | // Gyro = Rads
121
                    (0 << 0);  // Accelerometer = m/s^2
122
  write8(BNO055_UNIT_SEL_ADDR, unitsel);
123
  */
124

    
125
  /* Configure axis mapping (see section 3.4) */
126
  /*
127
  write8(BNO055_AXIS_MAP_CONFIG_ADDR, REMAP_CONFIG_P2); // P0-P7, Default is P1
128
  delay(10);
129
  write8(BNO055_AXIS_MAP_SIGN_ADDR, REMAP_SIGN_P2); // P0-P7, Default is P1
130
  delay(10);
131
  */
132

    
133
  write8(BNO055_SYS_TRIGGER_ADDR, 0x0);
134
  delay(10);
135
  /* Set the requested operating mode (see section 3.3) */
136
  setMode(mode);
137
  delay(20);
138

    
139
  return true;
140
}
141

    
142
/*!
143
 *  @brief  Puts the chip in the specified operating mode
144
 *  @param  mode
145
 *          mode values
146
 *           [OPERATION_MODE_CONFIG,
147
 *            OPERATION_MODE_ACCONLY,
148
 *            OPERATION_MODE_MAGONLY,
149
 *            OPERATION_MODE_GYRONLY,
150
 *            OPERATION_MODE_ACCMAG,
151
 *            OPERATION_MODE_ACCGYRO,
152
 *            OPERATION_MODE_MAGGYRO,
153
 *            OPERATION_MODE_AMG,
154
 *            OPERATION_MODE_IMUPLUS,
155
 *            OPERATION_MODE_COMPASS,
156
 *            OPERATION_MODE_M4G,
157
 *            OPERATION_MODE_NDOF_FMC_OFF,
158
 *            OPERATION_MODE_NDOF]
159
 */
160
void Adafruit_BNO055::setMode(adafruit_bno055_opmode_t mode) {
161
  _mode = mode;
162
  write8(BNO055_OPR_MODE_ADDR, _mode);
163
  delay(30);
164
}
165

    
166
/*!
167
 *  @brief  Changes the chip's axis remap
168
 *  @param  remapcode
169
 *          remap code possible values
170
 *          [REMAP_CONFIG_P0
171
 *           REMAP_CONFIG_P1 (default)
172
 *           REMAP_CONFIG_P2
173
 *           REMAP_CONFIG_P3
174
 *           REMAP_CONFIG_P4
175
 *           REMAP_CONFIG_P5
176
 *           REMAP_CONFIG_P6
177
 *           REMAP_CONFIG_P7]
178
 */
179
void Adafruit_BNO055::setAxisRemap(
180
    adafruit_bno055_axis_remap_config_t remapcode) {
181
  adafruit_bno055_opmode_t modeback = _mode;
182

    
183
  setMode(OPERATION_MODE_CONFIG);
184
  delay(25);
185
  write8(BNO055_AXIS_MAP_CONFIG_ADDR, remapcode);
186
  delay(10);
187
  /* Set the requested operating mode (see section 3.3) */
188
  setMode(modeback);
189
  delay(20);
190
}
191

    
192
/*!
193
 *  @brief  Changes the chip's axis signs
194
 *  @param  remapsign
195
 *          remap sign possible values
196
 *          [REMAP_SIGN_P0
197
 *           REMAP_SIGN_P1 (default)
198
 *           REMAP_SIGN_P2
199
 *           REMAP_SIGN_P3
200
 *           REMAP_SIGN_P4
201
 *           REMAP_SIGN_P5
202
 *           REMAP_SIGN_P6
203
 *           REMAP_SIGN_P7]
204
 */
205
void Adafruit_BNO055::setAxisSign(adafruit_bno055_axis_remap_sign_t remapsign) {
206
  adafruit_bno055_opmode_t modeback = _mode;
207

    
208
  setMode(OPERATION_MODE_CONFIG);
209
  delay(25);
210
  write8(BNO055_AXIS_MAP_SIGN_ADDR, remapsign);
211
  delay(10);
212
  /* Set the requested operating mode (see section 3.3) */
213
  setMode(modeback);
214
  delay(20);
215
}
216

    
217
/*!
218
 *  @brief  Use the external 32.768KHz crystal
219
 *  @param  usextal
220
 *          use external crystal boolean
221
 */
222
void Adafruit_BNO055::setExtCrystalUse(boolean usextal) {
223
  adafruit_bno055_opmode_t modeback = _mode;
224

    
225
  /* Switch to config mode (just in case since this is the default) */
226
  setMode(OPERATION_MODE_CONFIG);
227
  delay(25);
228
  write8(BNO055_PAGE_ID_ADDR, 0);
229
  if (usextal) {
230
    write8(BNO055_SYS_TRIGGER_ADDR, 0x80);
231
  } else {
232
    write8(BNO055_SYS_TRIGGER_ADDR, 0x00);
233
  }
234
  delay(10);
235
  /* Set the requested operating mode (see section 3.3) */
236
  setMode(modeback);
237
  delay(20);
238
}
239

    
240
/*!
241
 *   @brief  Gets the latest system status info
242
 *   @param  system_status
243
 *           system status info
244
 *   @param  self_test_result
245
 *           self test result
246
 *   @param  system_error
247
 *           system error info
248
 */
249
void Adafruit_BNO055::getSystemStatus(uint8_t *system_status,
250
                                      uint8_t *self_test_result,
251
                                      uint8_t *system_error) {
252
  write8(BNO055_PAGE_ID_ADDR, 0);
253

    
254
  /* System Status (see section 4.3.58)
255
     0 = Idle
256
     1 = System Error
257
     2 = Initializing Peripherals
258
     3 = System Iniitalization
259
     4 = Executing Self-Test
260
     5 = Sensor fusio algorithm running
261
     6 = System running without fusion algorithms
262
   */
263

    
264
  if (system_status != 0)
265
    *system_status = read8(BNO055_SYS_STAT_ADDR);
266

    
267
  /* Self Test Results
268
     1 = test passed, 0 = test failed
269

270
     Bit 0 = Accelerometer self test
271
     Bit 1 = Magnetometer self test
272
     Bit 2 = Gyroscope self test
273
     Bit 3 = MCU self test
274

275
     0x0F = all good!
276
   */
277

    
278
  if (self_test_result != 0)
279
    *self_test_result = read8(BNO055_SELFTEST_RESULT_ADDR);
280

    
281
  /* System Error (see section 4.3.59)
282
     0 = No error
283
     1 = Peripheral initialization error
284
     2 = System initialization error
285
     3 = Self test result failed
286
     4 = Register map value out of range
287
     5 = Register map address out of range
288
     6 = Register map write error
289
     7 = BNO low power mode not available for selected operat ion mode
290
     8 = Accelerometer power mode not available
291
     9 = Fusion algorithm configuration error
292
     A = Sensor configuration error
293
   */
294

    
295
  if (system_error != 0)
296
    *system_error = read8(BNO055_SYS_ERR_ADDR);
297

    
298
  delay(200);
299
}
300

    
301
/*!
302
 *  @brief  Gets the chip revision numbers
303
 *  @param  info
304
 *          revision info
305
 */
306
void Adafruit_BNO055::getRevInfo(adafruit_bno055_rev_info_t *info) {
307
  uint8_t a, b;
308

    
309
  memset(info, 0, sizeof(adafruit_bno055_rev_info_t));
310

    
311
  /* Check the accelerometer revision */
312
  info->accel_rev = read8(BNO055_ACCEL_REV_ID_ADDR);
313

    
314
  /* Check the magnetometer revision */
315
  info->mag_rev = read8(BNO055_MAG_REV_ID_ADDR);
316

    
317
  /* Check the gyroscope revision */
318
  info->gyro_rev = read8(BNO055_GYRO_REV_ID_ADDR);
319

    
320
  /* Check the SW revision */
321
  info->bl_rev = read8(BNO055_BL_REV_ID_ADDR);
322

    
323
  a = read8(BNO055_SW_REV_ID_LSB_ADDR);
324
  b = read8(BNO055_SW_REV_ID_MSB_ADDR);
325
  info->sw_rev = (((uint16_t)b) << 8) | ((uint16_t)a);
326
}
327

    
328
/*!
329
 *  @brief  Gets current calibration state.  Each value should be a uint8_t
330
 *          pointer and it will be set to 0 if not calibrated and 3 if
331
 *          fully calibrated.
332
 *          See section 34.3.54
333
 *  @param  sys
334
 *          Current system calibration status, depends on status of all sensors,
335
 * read-only
336
 *  @param  gyro
337
 *          Current calibration status of Gyroscope, read-only
338
 *  @param  accel
339
 *          Current calibration status of Accelerometer, read-only
340
 *  @param  mag
341
 *          Current calibration status of Magnetometer, read-only
342
 */
343
void Adafruit_BNO055::getCalibration(uint8_t *sys, uint8_t *gyro,
344
                                     uint8_t *accel, uint8_t *mag) {
345
  uint8_t calData = read8(BNO055_CALIB_STAT_ADDR);
346
  if (sys != NULL) {
347
    *sys = (calData >> 6) & 0x03;
348
  }
349
  if (gyro != NULL) {
350
    *gyro = (calData >> 4) & 0x03;
351
  }
352
  if (accel != NULL) {
353
    *accel = (calData >> 2) & 0x03;
354
  }
355
  if (mag != NULL) {
356
    *mag = calData & 0x03;
357
  }
358
}
359

    
360
/*!
361
 *  @brief  Gets the temperature in degrees celsius
362
 *  @return temperature in degrees celsius
363
 */
364
int8_t Adafruit_BNO055::getTemp() {
365
  int8_t temp = (int8_t)(read8(BNO055_TEMP_ADDR));
366
  return temp;
367
}
368

    
369
/*!
370
 *  @brief   Gets a vector reading from the specified source
371
 *  @param   vector_type
372
 *           possible vector type values
373
 *           [VECTOR_ACCELEROMETER
374
 *            VECTOR_MAGNETOMETER
375
 *            VECTOR_GYROSCOPE
376
 *            VECTOR_EULER
377
 *            VECTOR_LINEARACCEL
378
 *            VECTOR_GRAVITY]
379
 *  @return  vector from specified source
380
 */
381
imu::Vector<3> Adafruit_BNO055::getVector(adafruit_vector_type_t vector_type) {
382
  imu::Vector<3> xyz;
383
  uint8_t buffer[6];
384
  memset(buffer, 0, 6);
385

    
386
  int16_t x, y, z;
387
  x = y = z = 0;
388

    
389
  /* Read vector data (6 bytes) */
390
  readLen((adafruit_bno055_reg_t)vector_type, buffer, 6);
391

    
392
  x = ((int16_t)buffer[0]) | (((int16_t)buffer[1]) << 8);
393
  y = ((int16_t)buffer[2]) | (((int16_t)buffer[3]) << 8);
394
  z = ((int16_t)buffer[4]) | (((int16_t)buffer[5]) << 8);
395

    
396
  /*!
397
   * Convert the value to an appropriate range (section 3.6.4)
398
   * and assign the value to the Vector type
399
   */
400
  switch (vector_type) {
401
  case VECTOR_MAGNETOMETER:
402
    /* 1uT = 16 LSB */
403
    xyz[0] = ((double)x) / 16.0;
404
    xyz[1] = ((double)y) / 16.0;
405
    xyz[2] = ((double)z) / 16.0;
406
    break;
407
  case VECTOR_GYROSCOPE:
408
    /* 1dps = 16 LSB */
409
    xyz[0] = ((double)x) / 16.0;
410
    xyz[1] = ((double)y) / 16.0;
411
    xyz[2] = ((double)z) / 16.0;
412
    break;
413
  case VECTOR_EULER:
414
    /* 1 degree = 16 LSB */
415
    xyz[0] = ((double)x) / 16.0;
416
    xyz[1] = ((double)y) / 16.0;
417
    xyz[2] = ((double)z) / 16.0;
418
    break;
419
  case VECTOR_ACCELEROMETER:
420
    /* 1m/s^2 = 100 LSB */
421
    xyz[0] = ((double)x) / 100.0;
422
    xyz[1] = ((double)y) / 100.0;
423
    xyz[2] = ((double)z) / 100.0;
424
    break;
425
  case VECTOR_LINEARACCEL:
426
    /* 1m/s^2 = 100 LSB */
427
    xyz[0] = ((double)x) / 100.0;
428
    xyz[1] = ((double)y) / 100.0;
429
    xyz[2] = ((double)z) / 100.0;
430
    break;
431
  case VECTOR_GRAVITY:
432
    /* 1m/s^2 = 100 LSB */
433
    xyz[0] = ((double)x) / 100.0;
434
    xyz[1] = ((double)y) / 100.0;
435
    xyz[2] = ((double)z) / 100.0;
436
    break;
437
  }
438

    
439
  return xyz;
440
}
441

    
442
/*!
443
 *  @brief  Gets a quaternion reading from the specified source
444
 *  @return quaternion reading
445
 */
446
imu::Quaternion Adafruit_BNO055::getQuat() {
447
  uint8_t buffer[8];
448
  memset(buffer, 0, 8);
449

    
450
  int16_t x, y, z, w;
451
  x = y = z = w = 0;
452

    
453
  /* Read quat data (8 bytes) */
454
  readLen(BNO055_QUATERNION_DATA_W_LSB_ADDR, buffer, 8);
455
  w = (((uint16_t)buffer[1]) << 8) | ((uint16_t)buffer[0]);
456
  x = (((uint16_t)buffer[3]) << 8) | ((uint16_t)buffer[2]);
457
  y = (((uint16_t)buffer[5]) << 8) | ((uint16_t)buffer[4]);
458
  z = (((uint16_t)buffer[7]) << 8) | ((uint16_t)buffer[6]);
459

    
460
  /*!
461
   * Assign to Quaternion
462
   * See
463
   * http://ae-bst.resource.bosch.com/media/products/dokumente/bno055/BST_BNO055_DS000_12~1.pdf
464
   * 3.6.5.5 Orientation (Quaternion)
465
   */
466
  const double scale = (1.0 / (1 << 14));
467
  imu::Quaternion quat(scale * w, scale * x, scale * y, scale * z);
468
  return quat;
469
}
470

    
471
/*!
472
 *  @brief  Provides the sensor_t data for this sensor
473
 *  @param  sensor
474
 *          Sensor description
475
 */
476
void Adafruit_BNO055::getSensor(sensor_t *sensor) {
477
  /* Clear the sensor_t object */
478
  memset(sensor, 0, sizeof(sensor_t));
479

    
480
  /* Insert the sensor name in the fixed length char array */
481
  strncpy(sensor->name, "BNO055", sizeof(sensor->name) - 1);
482
  sensor->name[sizeof(sensor->name) - 1] = 0;
483
  sensor->version = 1;
484
  sensor->sensor_id = _sensorID;
485
  sensor->type = SENSOR_TYPE_ORIENTATION;
486
  sensor->min_delay = 0;
487
  sensor->max_value = 0.0F;
488
  sensor->min_value = 0.0F;
489
  sensor->resolution = 0.01F;
490
}
491

    
492
/*!
493
 *  @brief  Reads the sensor and returns the data as a sensors_event_t
494
 *  @param  event
495
 *          Event description
496
 *  @return always returns true
497
 */
498
bool Adafruit_BNO055::getEvent(sensors_event_t *event) {
499
  /* Clear the event */
500
  memset(event, 0, sizeof(sensors_event_t));
501

    
502
  event->version = sizeof(sensors_event_t);
503
  event->sensor_id = _sensorID;
504
  event->type = SENSOR_TYPE_ORIENTATION;
505
  event->timestamp = millis();
506

    
507
  /* Get a Euler angle sample for orientation */
508
  imu::Vector<3> euler = getVector(Adafruit_BNO055::VECTOR_EULER);
509
  event->orientation.x = euler.x();
510
  event->orientation.y = euler.y();
511
  event->orientation.z = euler.z();
512

    
513
  return true;
514
}
515

    
516
/*!
517
 *  @brief  Reads the sensor and returns the data as a sensors_event_t
518
 *  @param  event
519
 *          Event description
520
 *  @param  vec_type
521
 *          specify the type of reading
522
 *  @return always returns true
523
 */
524
bool Adafruit_BNO055::getEvent(sensors_event_t *event, adafruit_vector_type_t vec_type)
525
{
526
  /* Clear the event */
527
  memset(event, 0, sizeof(sensors_event_t));
528

    
529
  event->version = sizeof(sensors_event_t);
530
  event->sensor_id = _sensorID;
531
  event->timestamp = millis();
532

    
533
  //read the data according to vec_type
534
  imu::Vector<3> vec;
535
  if (vec_type == Adafruit_BNO055::VECTOR_LINEARACCEL)
536
  {
537
    event->type = SENSOR_TYPE_LINEAR_ACCELERATION;
538
    vec = getVector(Adafruit_BNO055::VECTOR_LINEARACCEL);
539

    
540
    event->acceleration.x = vec.x();
541
    event->acceleration.y = vec.y();
542
    event->acceleration.z = vec.z();
543
  }
544
  else if (vec_type == Adafruit_BNO055::VECTOR_ACCELEROMETER)
545
  {
546
    event->type = SENSOR_TYPE_ACCELEROMETER;
547
    vec = getVector(Adafruit_BNO055::VECTOR_ACCELEROMETER);
548

    
549
    event->acceleration.x = vec.x();
550
    event->acceleration.y = vec.y();
551
    event->acceleration.z = vec.z();
552
  }
553
  else if (vec_type == Adafruit_BNO055::VECTOR_GRAVITY)
554
  {
555
    event->type = SENSOR_TYPE_ACCELEROMETER;
556
    vec = getVector(Adafruit_BNO055::VECTOR_GRAVITY);
557

    
558
    event->acceleration.x = vec.x();
559
    event->acceleration.y = vec.y();
560
    event->acceleration.z = vec.z();
561
  }
562
  else if (vec_type == Adafruit_BNO055::VECTOR_EULER)
563
  {
564
    event->type = SENSOR_TYPE_ORIENTATION;
565
    vec = getVector(Adafruit_BNO055::VECTOR_EULER);
566

    
567
    event->orientation.x = vec.x();
568
    event->orientation.y = vec.y();
569
    event->orientation.z = vec.z();
570
  }
571
  else if (vec_type == Adafruit_BNO055::VECTOR_GYROSCOPE)
572
  {
573
    event->type = SENSOR_TYPE_ROTATION_VECTOR;
574
    vec = getVector(Adafruit_BNO055::VECTOR_GYROSCOPE);
575

    
576
    event->gyro.x = vec.x();
577
    event->gyro.y = vec.y();
578
    event->gyro.z = vec.z();
579
  }
580
  else if (vec_type == Adafruit_BNO055::VECTOR_MAGNETOMETER)
581
  {
582
    event->type = SENSOR_TYPE_MAGNETIC_FIELD;
583
    vec = getVector(Adafruit_BNO055::VECTOR_MAGNETOMETER);
584

    
585
    event->magnetic.x = vec.x();
586
    event->magnetic.y = vec.y();
587
    event->magnetic.z = vec.z();
588
  }
589
  
590

    
591
  return true;
592
}
593

    
594

    
595
/*!
596
 *  @brief  Reads the sensor's offset registers into a byte array
597
 *  @param  calibData
598
 *          Calibration offset (buffer size should be 22)
599
 *  @return true if read is successful
600
 */
601
bool Adafruit_BNO055::getSensorOffsets(uint8_t *calibData) {
602
  if (isFullyCalibrated()) {
603
    adafruit_bno055_opmode_t lastMode = _mode;
604
    setMode(OPERATION_MODE_CONFIG);
605

    
606
    readLen(ACCEL_OFFSET_X_LSB_ADDR, calibData, NUM_BNO055_OFFSET_REGISTERS);
607

    
608
    setMode(lastMode);
609
    return true;
610
  }
611
  return false;
612
}
613

    
614
/*!
615
 *  @brief  Reads the sensor's offset registers into an offset struct
616
 *  @param  offsets_type
617
 *          type of offsets
618
 *  @return true if read is successful
619
 */
620
bool Adafruit_BNO055::getSensorOffsets(
621
    adafruit_bno055_offsets_t &offsets_type) {
622
  if (isFullyCalibrated()) {
623
    adafruit_bno055_opmode_t lastMode = _mode;
624
    setMode(OPERATION_MODE_CONFIG);
625
    delay(25);
626

    
627
    /* Accel offset range depends on the G-range:
628
       +/-2g  = +/- 2000 mg
629
       +/-4g  = +/- 4000 mg
630
       +/-8g  = +/- 8000 mg
631
       +/-1§g = +/- 16000 mg */
632
    offsets_type.accel_offset_x = (read8(ACCEL_OFFSET_X_MSB_ADDR) << 8) |
633
                                  (read8(ACCEL_OFFSET_X_LSB_ADDR));
634
    offsets_type.accel_offset_y = (read8(ACCEL_OFFSET_Y_MSB_ADDR) << 8) |
635
                                  (read8(ACCEL_OFFSET_Y_LSB_ADDR));
636
    offsets_type.accel_offset_z = (read8(ACCEL_OFFSET_Z_MSB_ADDR) << 8) |
637
                                  (read8(ACCEL_OFFSET_Z_LSB_ADDR));
638

    
639
    /* Magnetometer offset range = +/- 6400 LSB where 1uT = 16 LSB */
640
    offsets_type.mag_offset_x =
641
        (read8(MAG_OFFSET_X_MSB_ADDR) << 8) | (read8(MAG_OFFSET_X_LSB_ADDR));
642
    offsets_type.mag_offset_y =
643
        (read8(MAG_OFFSET_Y_MSB_ADDR) << 8) | (read8(MAG_OFFSET_Y_LSB_ADDR));
644
    offsets_type.mag_offset_z =
645
        (read8(MAG_OFFSET_Z_MSB_ADDR) << 8) | (read8(MAG_OFFSET_Z_LSB_ADDR));
646

    
647
    /* Gyro offset range depends on the DPS range:
648
      2000 dps = +/- 32000 LSB
649
      1000 dps = +/- 16000 LSB
650
       500 dps = +/- 8000 LSB
651
       250 dps = +/- 4000 LSB
652
       125 dps = +/- 2000 LSB
653
       ... where 1 DPS = 16 LSB */
654
    offsets_type.gyro_offset_x =
655
        (read8(GYRO_OFFSET_X_MSB_ADDR) << 8) | (read8(GYRO_OFFSET_X_LSB_ADDR));
656
    offsets_type.gyro_offset_y =
657
        (read8(GYRO_OFFSET_Y_MSB_ADDR) << 8) | (read8(GYRO_OFFSET_Y_LSB_ADDR));
658
    offsets_type.gyro_offset_z =
659
        (read8(GYRO_OFFSET_Z_MSB_ADDR) << 8) | (read8(GYRO_OFFSET_Z_LSB_ADDR));
660

    
661
    /* Accelerometer radius = +/- 1000 LSB */
662
    offsets_type.accel_radius =
663
        (read8(ACCEL_RADIUS_MSB_ADDR) << 8) | (read8(ACCEL_RADIUS_LSB_ADDR));
664

    
665
    /* Magnetometer radius = +/- 960 LSB */
666
    offsets_type.mag_radius =
667
        (read8(MAG_RADIUS_MSB_ADDR) << 8) | (read8(MAG_RADIUS_LSB_ADDR));
668

    
669
    setMode(lastMode);
670
    return true;
671
  }
672
  return false;
673
}
674

    
675
/*!
676
 *  @brief  Writes an array of calibration values to the sensor's offset
677
 *  @param  calibData
678
 *          calibration data
679
 */
680
void Adafruit_BNO055::setSensorOffsets(const uint8_t *calibData) {
681
  adafruit_bno055_opmode_t lastMode = _mode;
682
  setMode(OPERATION_MODE_CONFIG);
683
  delay(25);
684

    
685
  /* Note: Configuration will take place only when user writes to the last
686
     byte of each config data pair (ex. ACCEL_OFFSET_Z_MSB_ADDR, etc.).
687
     Therefore the last byte must be written whenever the user wants to
688
     changes the configuration. */
689

    
690
  /* A writeLen() would make this much cleaner */
691
  write8(ACCEL_OFFSET_X_LSB_ADDR, calibData[0]);
692
  write8(ACCEL_OFFSET_X_MSB_ADDR, calibData[1]);
693
  write8(ACCEL_OFFSET_Y_LSB_ADDR, calibData[2]);
694
  write8(ACCEL_OFFSET_Y_MSB_ADDR, calibData[3]);
695
  write8(ACCEL_OFFSET_Z_LSB_ADDR, calibData[4]);
696
  write8(ACCEL_OFFSET_Z_MSB_ADDR, calibData[5]);
697

    
698
  write8(MAG_OFFSET_X_LSB_ADDR, calibData[6]);
699
  write8(MAG_OFFSET_X_MSB_ADDR, calibData[7]);
700
  write8(MAG_OFFSET_Y_LSB_ADDR, calibData[8]);
701
  write8(MAG_OFFSET_Y_MSB_ADDR, calibData[9]);
702
  write8(MAG_OFFSET_Z_LSB_ADDR, calibData[10]);
703
  write8(MAG_OFFSET_Z_MSB_ADDR, calibData[11]);
704

    
705
  write8(GYRO_OFFSET_X_LSB_ADDR, calibData[12]);
706
  write8(GYRO_OFFSET_X_MSB_ADDR, calibData[13]);
707
  write8(GYRO_OFFSET_Y_LSB_ADDR, calibData[14]);
708
  write8(GYRO_OFFSET_Y_MSB_ADDR, calibData[15]);
709
  write8(GYRO_OFFSET_Z_LSB_ADDR, calibData[16]);
710
  write8(GYRO_OFFSET_Z_MSB_ADDR, calibData[17]);
711

    
712
  write8(ACCEL_RADIUS_LSB_ADDR, calibData[18]);
713
  write8(ACCEL_RADIUS_MSB_ADDR, calibData[19]);
714

    
715
  write8(MAG_RADIUS_LSB_ADDR, calibData[20]);
716
  write8(MAG_RADIUS_MSB_ADDR, calibData[21]);
717

    
718
  setMode(lastMode);
719
}
720

    
721
/*!
722
 *  @brief  Writes to the sensor's offset registers from an offset struct
723
 *  @param  offsets_type
724
 *          accel_offset_x = acceleration offset x
725
 *          accel_offset_y = acceleration offset y
726
 *          accel_offset_z = acceleration offset z
727
 *
728
 *          mag_offset_x   = magnetometer offset x
729
 *          mag_offset_y   = magnetometer offset y
730
 *          mag_offset_z   = magnetometer offset z
731
 *
732
 *          gyro_offset_x  = gyroscrope offset x
733
 *          gyro_offset_y  = gyroscrope offset y
734
 *          gyro_offset_z  = gyroscrope offset z
735
 */
736
void Adafruit_BNO055::setSensorOffsets(
737
    const adafruit_bno055_offsets_t &offsets_type) {
738
  adafruit_bno055_opmode_t lastMode = _mode;
739
  setMode(OPERATION_MODE_CONFIG);
740
  delay(25);
741

    
742
  /* Note: Configuration will take place only when user writes to the last
743
     byte of each config data pair (ex. ACCEL_OFFSET_Z_MSB_ADDR, etc.).
744
     Therefore the last byte must be written whenever the user wants to
745
     changes the configuration. */
746

    
747
  write8(ACCEL_OFFSET_X_LSB_ADDR, (offsets_type.accel_offset_x) & 0x0FF);
748
  write8(ACCEL_OFFSET_X_MSB_ADDR, (offsets_type.accel_offset_x >> 8) & 0x0FF);
749
  write8(ACCEL_OFFSET_Y_LSB_ADDR, (offsets_type.accel_offset_y) & 0x0FF);
750
  write8(ACCEL_OFFSET_Y_MSB_ADDR, (offsets_type.accel_offset_y >> 8) & 0x0FF);
751
  write8(ACCEL_OFFSET_Z_LSB_ADDR, (offsets_type.accel_offset_z) & 0x0FF);
752
  write8(ACCEL_OFFSET_Z_MSB_ADDR, (offsets_type.accel_offset_z >> 8) & 0x0FF);
753

    
754
  write8(MAG_OFFSET_X_LSB_ADDR, (offsets_type.mag_offset_x) & 0x0FF);
755
  write8(MAG_OFFSET_X_MSB_ADDR, (offsets_type.mag_offset_x >> 8) & 0x0FF);
756
  write8(MAG_OFFSET_Y_LSB_ADDR, (offsets_type.mag_offset_y) & 0x0FF);
757
  write8(MAG_OFFSET_Y_MSB_ADDR, (offsets_type.mag_offset_y >> 8) & 0x0FF);
758
  write8(MAG_OFFSET_Z_LSB_ADDR, (offsets_type.mag_offset_z) & 0x0FF);
759
  write8(MAG_OFFSET_Z_MSB_ADDR, (offsets_type.mag_offset_z >> 8) & 0x0FF);
760

    
761
  write8(GYRO_OFFSET_X_LSB_ADDR, (offsets_type.gyro_offset_x) & 0x0FF);
762
  write8(GYRO_OFFSET_X_MSB_ADDR, (offsets_type.gyro_offset_x >> 8) & 0x0FF);
763
  write8(GYRO_OFFSET_Y_LSB_ADDR, (offsets_type.gyro_offset_y) & 0x0FF);
764
  write8(GYRO_OFFSET_Y_MSB_ADDR, (offsets_type.gyro_offset_y >> 8) & 0x0FF);
765
  write8(GYRO_OFFSET_Z_LSB_ADDR, (offsets_type.gyro_offset_z) & 0x0FF);
766
  write8(GYRO_OFFSET_Z_MSB_ADDR, (offsets_type.gyro_offset_z >> 8) & 0x0FF);
767

    
768
  write8(ACCEL_RADIUS_LSB_ADDR, (offsets_type.accel_radius) & 0x0FF);
769
  write8(ACCEL_RADIUS_MSB_ADDR, (offsets_type.accel_radius >> 8) & 0x0FF);
770

    
771
  write8(MAG_RADIUS_LSB_ADDR, (offsets_type.mag_radius) & 0x0FF);
772
  write8(MAG_RADIUS_MSB_ADDR, (offsets_type.mag_radius >> 8) & 0x0FF);
773

    
774
  setMode(lastMode);
775
}
776

    
777
/*!
778
 *  @brief  Checks of all cal status values are set to 3 (fully calibrated)
779
 *  @return status of calibration
780
 */
781
bool Adafruit_BNO055::isFullyCalibrated() {
782
  uint8_t system, gyro, accel, mag;
783
  getCalibration(&system, &gyro, &accel, &mag);
784

    
785
  switch (_mode) {
786
  case OPERATION_MODE_ACCONLY:
787
    return (accel == 3);
788
  case OPERATION_MODE_MAGONLY:
789
    return (mag == 3);
790
  case OPERATION_MODE_GYRONLY:
791
  case OPERATION_MODE_M4G: /* No magnetometer calibration required. */
792
    return (gyro == 3);
793
  case OPERATION_MODE_ACCMAG:
794
  case OPERATION_MODE_COMPASS:
795
    return (accel == 3 && mag == 3);
796
  case OPERATION_MODE_ACCGYRO:
797
  case OPERATION_MODE_IMUPLUS:
798
    return (accel == 3 && gyro == 3);
799
  case OPERATION_MODE_MAGGYRO:
800
    return (mag == 3 && gyro == 3);
801
  default:
802
    return (system == 3 && gyro == 3 && accel == 3 && mag == 3);
803
  }
804
}
805

    
806
/*!
807
 *  @brief  Enter Suspend mode (i.e., sleep)
808
 */
809
void Adafruit_BNO055::enterSuspendMode() {
810
  adafruit_bno055_opmode_t modeback = _mode;
811

    
812
  /* Switch to config mode (just in case since this is the default) */
813
  setMode(OPERATION_MODE_CONFIG);
814
  delay(25);
815
  write8(BNO055_PWR_MODE_ADDR, 0x02);
816
  /* Set the requested operating mode (see section 3.3) */
817
  setMode(modeback);
818
  delay(20);
819
}
820

    
821
/*!
822
 *  @brief  Enter Normal mode (i.e., wake)
823
 */
824
void Adafruit_BNO055::enterNormalMode() {
825
  adafruit_bno055_opmode_t modeback = _mode;
826

    
827
  /* Switch to config mode (just in case since this is the default) */
828
  setMode(OPERATION_MODE_CONFIG);
829
  delay(25);
830
  write8(BNO055_PWR_MODE_ADDR, 0x00);
831
  /* Set the requested operating mode (see section 3.3) */
832
  setMode(modeback);
833
  delay(20);
834
}
835

    
836
/*!
837
 *  @brief  Writes an 8 bit value over I2C
838
 */
839
bool Adafruit_BNO055::write8(adafruit_bno055_reg_t reg, byte value) {
840
  _wire->beginTransmission(_address);
841
#if ARDUINO >= 100
842
  _wire->write((uint8_t)reg);
843
  _wire->write((uint8_t)value);
844
#else
845
  _wire->send(reg);
846
  _wire->send(value);
847
#endif
848
  _wire->endTransmission();
849

    
850
  /* ToDo: Check for error! */
851
  return true;
852
}
853

    
854
/*!
855
 *  @brief  Reads an 8 bit value over I2C
856
 */
857
byte Adafruit_BNO055::read8(adafruit_bno055_reg_t reg) {
858
  byte value = 0;
859

    
860
  _wire->beginTransmission(_address);
861
#if ARDUINO >= 100
862
  _wire->write((uint8_t)reg);
863
#else
864
  _wire->send(reg);
865
#endif
866
  _wire->endTransmission();
867
  _wire->requestFrom(_address, (byte)1);
868
#if ARDUINO >= 100
869
  value = _wire->read();
870
#else
871
  value = _wire->receive();
872
#endif
873

    
874
  return value;
875
}
876

    
877
/*!
878
 *  @brief  Reads the specified number of bytes over I2C
879
 */
880
bool Adafruit_BNO055::readLen(adafruit_bno055_reg_t reg, byte *buffer,
881
                              uint8_t len) {
882
  _wire->beginTransmission(_address);
883
#if ARDUINO >= 100
884
  _wire->write((uint8_t)reg);
885
#else
886
  _wire->send(reg);
887
#endif
888
  _wire->endTransmission();
889
  _wire->requestFrom(_address, (byte)len);
890

    
891
  for (uint8_t i = 0; i < len; i++) {
892
#if ARDUINO >= 100
893
    buffer[i] = _wire->read();
894
#else
895
    buffer[i] = _wire->receive();
896
#endif
897
  }
898

    
899
  /* ToDo: Check for errors! */
900
  return true;
901
}