Statistics
| Branch: | Revision:

adafruit_bno055 / Adafruit_BNO055.cpp @ 5f6b7a75

History | View | Annotate | Download (25.946 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
 */
475
void Adafruit_BNO055::getSensor(sensor_t *sensor) {
476
  /* Clear the sensor_t object */
477
  memset(sensor, 0, sizeof(sensor_t));
478

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

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

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

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

    
511
  return true;
512
}
513

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

    
526
  event->version = sizeof(sensors_event_t);
527
  event->sensor_id = _sensorID;
528
  event->timestamp = millis();
529

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

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

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

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

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

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

    
582
    event->magnetic.x = vec.x();
583
    event->magnetic.y = vec.y();
584
    event->magnetic.z = vec.z();
585
  }
586
  
587

    
588
  return true;
589
}
590

    
591

    
592
/*!
593
 *  @brief  Reads the sensor's offset registers into a byte array
594
 *  @param  calibData
595
 *  @return true if read is successful
596
 */
597
bool Adafruit_BNO055::getSensorOffsets(uint8_t *calibData) {
598
  if (isFullyCalibrated()) {
599
    adafruit_bno055_opmode_t lastMode = _mode;
600
    setMode(OPERATION_MODE_CONFIG);
601

    
602
    readLen(ACCEL_OFFSET_X_LSB_ADDR, calibData, NUM_BNO055_OFFSET_REGISTERS);
603

    
604
    setMode(lastMode);
605
    return true;
606
  }
607
  return false;
608
}
609

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

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

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

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

    
657
    /* Accelerometer radius = +/- 1000 LSB */
658
    offsets_type.accel_radius =
659
        (read8(ACCEL_RADIUS_MSB_ADDR) << 8) | (read8(ACCEL_RADIUS_LSB_ADDR));
660

    
661
    /* Magnetometer radius = +/- 960 LSB */
662
    offsets_type.mag_radius =
663
        (read8(MAG_RADIUS_MSB_ADDR) << 8) | (read8(MAG_RADIUS_LSB_ADDR));
664

    
665
    setMode(lastMode);
666
    return true;
667
  }
668
  return false;
669
}
670

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

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

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

    
694
  write8(MAG_OFFSET_X_LSB_ADDR, calibData[6]);
695
  write8(MAG_OFFSET_X_MSB_ADDR, calibData[7]);
696
  write8(MAG_OFFSET_Y_LSB_ADDR, calibData[8]);
697
  write8(MAG_OFFSET_Y_MSB_ADDR, calibData[9]);
698
  write8(MAG_OFFSET_Z_LSB_ADDR, calibData[10]);
699
  write8(MAG_OFFSET_Z_MSB_ADDR, calibData[11]);
700

    
701
  write8(GYRO_OFFSET_X_LSB_ADDR, calibData[12]);
702
  write8(GYRO_OFFSET_X_MSB_ADDR, calibData[13]);
703
  write8(GYRO_OFFSET_Y_LSB_ADDR, calibData[14]);
704
  write8(GYRO_OFFSET_Y_MSB_ADDR, calibData[15]);
705
  write8(GYRO_OFFSET_Z_LSB_ADDR, calibData[16]);
706
  write8(GYRO_OFFSET_Z_MSB_ADDR, calibData[17]);
707

    
708
  write8(ACCEL_RADIUS_LSB_ADDR, calibData[18]);
709
  write8(ACCEL_RADIUS_MSB_ADDR, calibData[19]);
710

    
711
  write8(MAG_RADIUS_LSB_ADDR, calibData[20]);
712
  write8(MAG_RADIUS_MSB_ADDR, calibData[21]);
713

    
714
  setMode(lastMode);
715
}
716

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

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

    
743
  write8(ACCEL_OFFSET_X_LSB_ADDR, (offsets_type.accel_offset_x) & 0x0FF);
744
  write8(ACCEL_OFFSET_X_MSB_ADDR, (offsets_type.accel_offset_x >> 8) & 0x0FF);
745
  write8(ACCEL_OFFSET_Y_LSB_ADDR, (offsets_type.accel_offset_y) & 0x0FF);
746
  write8(ACCEL_OFFSET_Y_MSB_ADDR, (offsets_type.accel_offset_y >> 8) & 0x0FF);
747
  write8(ACCEL_OFFSET_Z_LSB_ADDR, (offsets_type.accel_offset_z) & 0x0FF);
748
  write8(ACCEL_OFFSET_Z_MSB_ADDR, (offsets_type.accel_offset_z >> 8) & 0x0FF);
749

    
750
  write8(MAG_OFFSET_X_LSB_ADDR, (offsets_type.mag_offset_x) & 0x0FF);
751
  write8(MAG_OFFSET_X_MSB_ADDR, (offsets_type.mag_offset_x >> 8) & 0x0FF);
752
  write8(MAG_OFFSET_Y_LSB_ADDR, (offsets_type.mag_offset_y) & 0x0FF);
753
  write8(MAG_OFFSET_Y_MSB_ADDR, (offsets_type.mag_offset_y >> 8) & 0x0FF);
754
  write8(MAG_OFFSET_Z_LSB_ADDR, (offsets_type.mag_offset_z) & 0x0FF);
755
  write8(MAG_OFFSET_Z_MSB_ADDR, (offsets_type.mag_offset_z >> 8) & 0x0FF);
756

    
757
  write8(GYRO_OFFSET_X_LSB_ADDR, (offsets_type.gyro_offset_x) & 0x0FF);
758
  write8(GYRO_OFFSET_X_MSB_ADDR, (offsets_type.gyro_offset_x >> 8) & 0x0FF);
759
  write8(GYRO_OFFSET_Y_LSB_ADDR, (offsets_type.gyro_offset_y) & 0x0FF);
760
  write8(GYRO_OFFSET_Y_MSB_ADDR, (offsets_type.gyro_offset_y >> 8) & 0x0FF);
761
  write8(GYRO_OFFSET_Z_LSB_ADDR, (offsets_type.gyro_offset_z) & 0x0FF);
762
  write8(GYRO_OFFSET_Z_MSB_ADDR, (offsets_type.gyro_offset_z >> 8) & 0x0FF);
763

    
764
  write8(ACCEL_RADIUS_LSB_ADDR, (offsets_type.accel_radius) & 0x0FF);
765
  write8(ACCEL_RADIUS_MSB_ADDR, (offsets_type.accel_radius >> 8) & 0x0FF);
766

    
767
  write8(MAG_RADIUS_LSB_ADDR, (offsets_type.mag_radius) & 0x0FF);
768
  write8(MAG_RADIUS_MSB_ADDR, (offsets_type.mag_radius >> 8) & 0x0FF);
769

    
770
  setMode(lastMode);
771
}
772

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

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

    
802
/*!
803
 *  @brief  Enter Suspend mode (i.e., sleep)
804
 */
805
void Adafruit_BNO055::enterSuspendMode() {
806
  adafruit_bno055_opmode_t modeback = _mode;
807

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

    
817
/*!
818
 *  @brief  Enter Normal mode (i.e., wake)
819
 */
820
void Adafruit_BNO055::enterNormalMode() {
821
  adafruit_bno055_opmode_t modeback = _mode;
822

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

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

    
846
  /* ToDo: Check for error! */
847
  return true;
848
}
849

    
850
/*!
851
 *  @brief  Reads an 8 bit value over I2C
852
 */
853
byte Adafruit_BNO055::read8(adafruit_bno055_reg_t reg) {
854
  byte value = 0;
855

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

    
870
  return value;
871
}
872

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

    
887
  for (uint8_t i = 0; i < len; i++) {
888
#if ARDUINO >= 100
889
    buffer[i] = _wire->read();
890
#else
891
    buffer[i] = _wire->receive();
892
#endif
893
  }
894

    
895
  /* ToDo: Check for errors! */
896
  return true;
897
}