flight/pios/common/pios_adxl345.c

   1 /**
   2  ******************************************************************************
   3  * @addtogroup PIOS PIOS Core hardware abstraction layer
   4  * @{
   5  * @addtogroup PIOS_ADXL345 ADXL345 Functions
   6  * @brief Deals with the hardware interface to the BMA180 3-axis accelerometer
   7  * @{
   8  *
   9  * @file       pios_adxl345.h
  10  * @author     The OpenPilot Team, http://www.openpilot.org Copyright (C) 2012.
  11  * @brief      PiOS ADXL345 digital accelerometer driver.
  12  * @see        The GNU Public License (GPL) Version 3
  13  *
  14  *****************************************************************************/
  15 /*
  16  * This program is free software; you can redistribute it and/or modify
  17  * it under the terms of the GNU General Public License as published by
  18  * the Free Software Foundation; either version 3 of the License, or
  19  * (at your option) any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful, but
  22  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  23  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  24  * for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License along
  27  * with this program; if not, write to the Free Software Foundation, Inc.,
  28  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  29  */
  30
  31 #include "pios.h"
  32
  33 #ifdef PIOS_INCLUDE_ADXL345
  34
  35 enum pios_adxl345_dev_magic {
  36     PIOS_ADXL345_DEV_MAGIC = 0xcb55aa55,
  37 };
  38
  39 struct adxl345_dev {
  40     uint32_t spi_id;
  41     uint32_t slave_num;
  42     enum pios_adxl345_dev_magic magic;
  43 };
  44
  45 // ! Global structure for this device device
  46 static struct adxl345_dev *dev;
  47
  48 // ! Private functions
  49 static struct adxl345_dev *PIOS_ADXL345_alloc(void);
  50 static int32_t PIOS_ADXL345_Validate(struct adxl345_dev *dev);
  51 static int32_t PIOS_ADXL345_ClaimBus();
  52 static int32_t PIOS_ADXL345_ReleaseBus();
  53 static int32_t PIOS_ADXL345_FifoDepth(uint8_t depth);
  54
  55 /**
  56  * @brief Allocate a new device
  57  */
  58 static struct adxl345_dev *PIOS_ADXL345_alloc(void)
  59 {
  60     struct adxl345_dev *adxl345_dev;
  61
  62     adxl345_dev = (struct adxl345_dev *)pios_malloc(sizeof(*adxl345_dev));
  63     if (!adxl345_dev) {
  64         return NULL;
  65     }
  66
  67     adxl345_dev->magic = PIOS_ADXL345_DEV_MAGIC;
  68     return adxl345_dev;
  69 }
  70
  71 /**
  72  * @brief Validate the handle to the spi device
  73  * @returns 0 for valid device or -1 otherwise
  74  */
  75 static int32_t PIOS_ADXL345_Validate(struct adxl345_dev *vdev)
  76 {
  77     if (vdev == NULL) {
  78         return -1;
  79     }
  80     if (vdev->magic != PIOS_ADXL345_DEV_MAGIC) {
  81         return -2;
  82     }
  83     if (vdev->spi_id == 0) {
  84         return -3;
  85     }
  86     return 0;
  87 }
  88
  89 /**
  90  * @brief Claim the SPI bus for the accel communications and select this chip
  91  * @return 0 for succesful claiming of bus or -1 otherwise
  92  */
  93 static int32_t PIOS_ADXL345_ClaimBus()
  94 {
  95     if (PIOS_ADXL345_Validate(dev) != 0) {
  96         return -1;
  97     }
  98
  99     if (PIOS_SPI_ClaimBus(dev->spi_id) != 0) {
 100         return -2;
 101     }
 102
 103     PIOS_SPI_RC_PinSet(dev->spi_id, dev->slave_num, 0);
 104
 105     return 0;
 106 }
 107
 108 /**
 109  * @brief Release the SPI bus for the accel communications and end the transaction
 110  * @return 0 if success or <0 for failure
 111  */
 112 static int32_t PIOS_ADXL345_ReleaseBus()
 113 {
 114     if (PIOS_ADXL345_Validate(dev) != 0) {
 115         return -1;
 116     }
 117
 118     PIOS_SPI_RC_PinSet(dev->spi_id, dev->slave_num, 1);
 119
 120     if (PIOS_SPI_ReleaseBus(dev->spi_id) != 0) {
 121         return -2;
 122     }
 123
 124     return 0;
 125 }
 126
 127 /**
 128  * @brief Select the sampling rate of the chip
 129  *
 130  * This also puts it into high power mode
 131  */
 132 int32_t PIOS_ADXL345_SelectRate(uint8_t rate)
 133 {
 134     if (PIOS_ADXL345_Validate(dev) != 0) {
 135         return -1;
 136     }
 137
 138     if (PIOS_ADXL345_ClaimBus() != 0) {
 139         return -2;
 140     }
 141
 142     uint8_t out[2] = { ADXL_RATE_ADDR, rate & 0x0F };
 143     if (PIOS_SPI_TransferBlock(dev->spi_id, out, NULL, sizeof(out), NULL) < 0) {
 144         PIOS_ADXL345_ReleaseBus();
 145         return -3;
 146     }
 147
 148     PIOS_ADXL345_ReleaseBus();
 149
 150     return 0;
 151 }
 152
 153 /**
 154  * @brief Set the range of the accelerometer and set the data to be right justified
 155  * with sign extension.  Also keep device in 4 wire mode.
 156  */
 157 int32_t PIOS_ADXL345_SetRange(uint8_t range)
 158 {
 159     if (PIOS_ADXL345_Validate(dev) != 0) {
 160         return -1;
 161     }
 162
 163     if (PIOS_ADXL345_ClaimBus() != 0) {
 164         return -2;
 165     }
 166
 167     uint8_t out[2] = { ADXL_FORMAT_ADDR, (range & 0x03) | ADXL_FULL_RES | ADXL_4WIRE };
 168     if (PIOS_SPI_TransferBlock(dev->spi_id, out, NULL, sizeof(out), NULL) < 0) {
 169         PIOS_ADXL345_ReleaseBus();
 170         return -3;
 171     }
 172
 173     PIOS_ADXL345_ReleaseBus();
 174
 175     return 0;
 176 }
 177
 178 /**
 179  * @brief Set the fifo depth that triggers an interrupt.  This will be matched to the oversampling
 180  */
 181 static int32_t PIOS_ADXL345_FifoDepth(uint8_t depth)
 182 {
 183     if (PIOS_ADXL345_Validate(dev) != 0) {
 184         return -1;
 185     }
 186
 187     if (PIOS_ADXL345_ClaimBus() != 0) {
 188         return -2;
 189     }
 190
 191     uint8_t out[2] = { ADXL_FIFO_ADDR, (depth & 0x1f) | ADXL_FIFO_STREAM };
 192     if (PIOS_SPI_TransferBlock(dev->spi_id, out, NULL, sizeof(out), NULL) < 0) {
 193         PIOS_ADXL345_ReleaseBus();
 194         return -3;
 195     }
 196
 197     PIOS_ADXL345_ReleaseBus();
 198
 199     return 0;
 200 }
 201
 202 /**
 203  * @brief Enable measuring.  This also disables the activity sensors (tap or free fall)
 204  */
 205 static int32_t PIOS_ADXL345_SetMeasure(__attribute__((unused)) uint8_t enable)
 206 {
 207     if (PIOS_ADXL345_Validate(dev) != 0) {
 208         return -1;
 209     }
 210
 211     if (PIOS_ADXL345_ClaimBus() != 0) {
 212         return -2;
 213     }
 214
 215     uint8_t out[2] = { ADXL_POWER_ADDR, ADXL_MEAURE };
 216     if (PIOS_SPI_TransferBlock(dev->spi_id, out, NULL, sizeof(out), NULL) < 0) {
 217         PIOS_ADXL345_ReleaseBus();
 218         return -3;
 219     }
 220
 221     PIOS_ADXL345_ReleaseBus();
 222
 223     return 0;
 224 }
 225
 226 /**
 227  * @brief Initialize with good default settings
 228  */
 229 int32_t PIOS_ADXL345_Init(uint32_t spi_id, uint32_t slave_num)
 230 {
 231     dev = PIOS_ADXL345_alloc();
 232     if (dev == NULL) {
 233         return -1;
 234     }
 235
 236     dev->spi_id    = spi_id;
 237     dev->slave_num = slave_num;
 238
 239     PIOS_ADXL345_ReleaseBus();
 240     PIOS_ADXL345_SelectRate(ADXL_RATE_1600);
 241     PIOS_ADXL345_SetRange(ADXL_RANGE_8G);
 242     PIOS_ADXL345_FifoDepth(16);
 243     PIOS_ADXL345_SetMeasure(1);
 244
 245     return 0;
 246 }
 247
 248 /**
 249  * @brief Return number of entries in the fifo
 250  */
 251 int32_t PIOS_ADXL345_Test()
 252 {
 253     if (PIOS_ADXL345_Validate(dev) != 0) {
 254         return -1;
 255     }
 256
 257     if (PIOS_ADXL345_ClaimBus() != 0) {
 258         return -2;
 259     }
 260
 261     uint8_t buf[2] = { 0, 0 };
 262     uint8_t rec[2] = { 0, 0 };
 263     buf[0] = ADXL_WHOAMI | ADXL_READ_BIT;
 264
 265     if (PIOS_SPI_TransferBlock(dev->spi_id, &buf[0], &rec[0], sizeof(buf), NULL) < 0) {
 266         PIOS_ADXL345_ReleaseBus();
 267         return -3;
 268     }
 269
 270     PIOS_ADXL345_ReleaseBus();
 271
 272     return (rec[1] == ADXL_DEVICE_ID) ? 0 : -4;
 273 }
 274
 275 /**
 276  * @brief Return number of entries in the fifo
 277  */
 278 int32_t PIOS_ADXL345_FifoElements()
 279 {
 280     if (PIOS_ADXL345_Validate(dev) != 0) {
 281         return -1;
 282     }
 283
 284     if (PIOS_ADXL345_ClaimBus() != 0) {
 285         return -2;
 286     }
 287
 288     uint8_t buf[2] = { 0, 0 };
 289     uint8_t rec[2] = { 0, 0 };
 290     buf[0] = ADXL_FIFOSTATUS_ADDR | ADXL_READ_BIT; // Read fifo status
 291
 292     if (PIOS_SPI_TransferBlock(dev->spi_id, &buf[0], &rec[0], sizeof(buf), NULL) < 0) {
 293         PIOS_ADXL345_ReleaseBus();
 294         return -3;
 295     }
 296
 297     PIOS_ADXL345_ReleaseBus();
 298
 299     return rec[1] & 0x3f;
 300 }
 301
 302
 303 /**
 304  * @brief Read a single set of values from the x y z channels
 305  * @returns The number of samples remaining in the fifo
 306  */
 307 uint8_t PIOS_ADXL345_Read(struct pios_adxl345_data *data)
 308 {
 309     if (PIOS_ADXL345_Validate(dev) != 0) {
 310         return -1;
 311     }
 312
 313     if (PIOS_ADXL345_ClaimBus() != 0) {
 314         return -2;
 315     }
 316     // To save memory use same buffer for in and out but offset by
 317     // a byte
 318     uint8_t buf[10] = { 0 };
 319     uint8_t *rec    = buf + 1;
 320     buf[0] = ADXL_X0_ADDR | ADXL_MULTI_BIT | ADXL_READ_BIT; // Multibyte read starting at X0
 321     if (PIOS_SPI_TransferBlock(dev->spi_id, &buf[0], &rec[0], 9, NULL) < 0) {
 322         PIOS_ADXL345_ReleaseBus();
 323         return -3;
 324     }
 325
 326     PIOS_ADXL345_ReleaseBus();
 327
 328     data->x = rec[1] + (rec[2] << 8);
 329     data->y = rec[3] + (rec[4] << 8);
 330     data->z = rec[5] + (rec[6] << 8);
 331
 332     return rec[8] & 0x7F; // return number of remaining entries
 333 }
 334
 335 /**
 336  * @brief Read a single set of values from the x y z channels
 337  * @returns 0 if successful
 338  */
 339
 340 int8_t PIOS_ADXL345_ReadAndAccumulateSamples(struct pios_adxl345_data *data, uint8_t samples)
 341 {
 342     if (PIOS_ADXL345_Validate(dev) != 0) {
 343         return -1;
 344     }
 345
 346     if (PIOS_ADXL345_ClaimBus() != 0) {
 347         return -2;
 348     }
 349     data->x = 0;
 350     data->y = 0;
 351     data->z = 0;
 352     // To save memory use same buffer for in and out but offset by
 353     // a byte
 354 #ifdef PIOS_INCLUDE_INSTRUMENTATION
 355     PIOS_Instrumentation_TimeStart(counterUpd);
 356 #endif
 357     for (uint8_t i = 0; i < samples; i++) {
 358         uint8_t buf[7] = { 0 };
 359         uint8_t *rec   = &buf[1];
 360         PIOS_SPI_RC_PinSet(dev->spi_id, dev->slave_num, 0);
 361         buf[0] = ADXL_X0_ADDR | ADXL_MULTI_BIT | ADXL_READ_BIT; // Multibyte read starting at X0
 362         if (PIOS_SPI_TransferBlock(dev->spi_id, &buf[0], &rec[0], 7, NULL) < 0) {
 363             PIOS_ADXL345_ReleaseBus();
 364             return -3;
 365         }
 366         PIOS_SPI_RC_PinSet(dev->spi_id, dev->slave_num, 1);
 367         data->x += rec[1] + (rec[2] << 8);
 368         data->y += rec[3] + (rec[4] << 8);
 369         data->z += rec[5] + (rec[6] << 8);
 370     }
 371     uint8_t r = PIOS_SPI_TransferByte(dev->spi_id, ADXL_FIFOSTATUS_ADDR | ADXL_READ_BIT);
 372 #ifdef PIOS_INCLUDE_INSTRUMENTATION
 373     PIOS_Instrumentation_TimeEnd(counterUpd);
 374 #endif
 375     PIOS_ADXL345_ReleaseBus();
 376     return r & 0x7F; // return number of remaining entries
 377 }
 378 #endif /* PIOS_INCLUDE_ADXL345 */