mirror of
https://bitbucket.org/librepilot/librepilot.git
synced 2024-11-30 08:24:11 +01:00
409 lines
10 KiB
C
409 lines
10 KiB
C
/**
|
|
******************************************************************************
|
|
* @addtogroup PIOS PIOS Core hardware abstraction layer
|
|
* @{
|
|
* @addtogroup PIOS_L3GD20 L3GD20 Functions
|
|
* @brief Deals with the hardware interface to the 3-axis gyro
|
|
* @{
|
|
*
|
|
* @file pios_l3gd20.c
|
|
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2012.
|
|
* @brief L3GD20 3-axis gyro chip
|
|
* @see The GNU Public License (GPL) Version 3
|
|
*
|
|
******************************************************************************
|
|
*/
|
|
/*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
/* Project Includes */
|
|
#include "pios.h"
|
|
|
|
#if defined(PIOS_INCLUDE_L3GD20)
|
|
|
|
#include "fifo_buffer.h"
|
|
|
|
/* Global Variables */
|
|
enum pios_l3gd20_dev_magic {
|
|
PIOS_L3GD20_DEV_MAGIC = 0x9d39bced,
|
|
};
|
|
|
|
#define PIOS_L3GD20_MAX_DOWNSAMPLE 10
|
|
struct l3gd20_dev {
|
|
uint32_t spi_id;
|
|
uint32_t slave_num;
|
|
int16_t buffer[PIOS_L3GD20_MAX_DOWNSAMPLE * sizeof(struct pios_l3gd20_data)];
|
|
t_fifo_buffer fifo;
|
|
const struct pios_l3gd20_cfg * cfg;
|
|
enum pios_l3gd20_filter bandwidth;
|
|
enum pios_l3gd20_range range;
|
|
enum pios_l3gd20_dev_magic magic;
|
|
};
|
|
|
|
//! Global structure for this device device
|
|
static struct l3gd20_dev * dev;
|
|
|
|
//! Private functions
|
|
static struct l3gd20_dev * PIOS_L3GD20_alloc(void);
|
|
static int32_t PIOS_L3GD20_Validate(struct l3gd20_dev * dev);
|
|
static void PIOS_L3GD20_Config(struct pios_l3gd20_cfg const * cfg);
|
|
static int32_t PIOS_L3GD20_SetReg(uint8_t address, uint8_t buffer);
|
|
static int32_t PIOS_L3GD20_GetReg(uint8_t address);
|
|
static int32_t PIOS_L3GD20_ClaimBus();
|
|
static int32_t PIOS_L3GD20_ClaimBusIsr();
|
|
static int32_t PIOS_L3GD20_ReleaseBus();
|
|
|
|
volatile bool l3gd20_configured = false;
|
|
|
|
/* Local Variables */
|
|
#define DEG_TO_RAD (M_PI / 180.0)
|
|
|
|
/**
|
|
* @brief Allocate a new device
|
|
*/
|
|
static struct l3gd20_dev * PIOS_L3GD20_alloc(void)
|
|
{
|
|
struct l3gd20_dev * l3gd20_dev;
|
|
|
|
l3gd20_dev = (struct l3gd20_dev *)pvPortMalloc(sizeof(*l3gd20_dev));
|
|
if (!l3gd20_dev) return (NULL);
|
|
|
|
fifoBuf_init(&l3gd20_dev->fifo, (uint8_t *) l3gd20_dev->buffer, sizeof(l3gd20_dev->buffer));
|
|
|
|
l3gd20_dev->magic = PIOS_L3GD20_DEV_MAGIC;
|
|
return(l3gd20_dev);
|
|
}
|
|
|
|
/**
|
|
* @brief Validate the handle to the spi device
|
|
* @returns 0 for valid device or -1 otherwise
|
|
*/
|
|
static int32_t PIOS_L3GD20_Validate(struct l3gd20_dev * dev)
|
|
{
|
|
if (dev == NULL)
|
|
return -1;
|
|
if (dev->magic != PIOS_L3GD20_DEV_MAGIC)
|
|
return -2;
|
|
if (dev->spi_id == 0)
|
|
return -3;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Initialize the MPU6050 3-axis gyro sensor.
|
|
* @return none
|
|
*/
|
|
#include <pios_board_info.h>
|
|
int32_t PIOS_L3GD20_Init(uint32_t spi_id, uint32_t slave_num, const struct pios_l3gd20_cfg * cfg)
|
|
{
|
|
dev = PIOS_L3GD20_alloc();
|
|
if(dev == NULL)
|
|
return -1;
|
|
|
|
dev->spi_id = spi_id;
|
|
dev->slave_num = slave_num;
|
|
dev->cfg = cfg;
|
|
|
|
/* Configure the MPU6050 Sensor */
|
|
PIOS_SPI_SetClockSpeed(dev->spi_id, SPI_BaudRatePrescaler_256);
|
|
PIOS_L3GD20_Config(cfg);
|
|
|
|
/* This should either use a real speed (constant across boards) or pull from */
|
|
/* the default configuration */
|
|
const struct pios_board_info * bdinfo = &pios_board_info_blob;
|
|
switch(bdinfo->board_type) {
|
|
case 0x04: /* CopterControl */
|
|
PIOS_SPI_SetClockSpeed(dev->spi_id, SPI_BaudRatePrescaler_8);
|
|
break;
|
|
default:
|
|
PIOS_SPI_SetClockSpeed(dev->spi_id, SPI_BaudRatePrescaler_16);
|
|
break;
|
|
}
|
|
|
|
/* Set up EXTI */
|
|
PIOS_EXTI_Init(cfg->exti_cfg);
|
|
|
|
// An initial read is needed to get it running
|
|
struct pios_l3gd20_data data;
|
|
PIOS_L3GD20_ReadGyros(&data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Initialize the L3GD20 3-axis gyro sensor
|
|
* \return none
|
|
* \param[in] PIOS_L3GD20_ConfigTypeDef struct to be used to configure sensor.
|
|
*
|
|
*/
|
|
static void PIOS_L3GD20_Config(struct pios_l3gd20_cfg const * cfg)
|
|
{
|
|
// This register enables the channels and sets the bandwidth
|
|
while(PIOS_L3GD20_SetReg(PIOS_L3GD20_CTRL_REG1, PIOS_L3GD20_CTRL1_FASTEST |
|
|
PIOS_L3GD20_CTRL1_PD | PIOS_L3GD20_CTRL1_ZEN |
|
|
PIOS_L3GD20_CTRL1_YEN | PIOS_L3GD20_CTRL1_XEN) != 0);
|
|
|
|
// Disable the high pass filters
|
|
while(PIOS_L3GD20_SetReg(PIOS_L3GD20_CTRL_REG2, 0) != 0);
|
|
// Set int2 to go high on data ready
|
|
while(PIOS_L3GD20_SetReg(PIOS_L3GD20_CTRL_REG3, 0x08) != 0);
|
|
// Select SPI interface, 500 deg/s, endianness?
|
|
while(PIOS_L3GD20_SetRange(cfg->range) != 0);
|
|
// Enable FIFO, disable HPF
|
|
while(PIOS_L3GD20_SetReg(PIOS_L3GD20_CTRL_REG5, 0x40) != 0);
|
|
// Fifo stream mode
|
|
while(PIOS_L3GD20_SetReg(PIOS_L3GD20_FIFO_CTRL_REG, 0x40) != 0);
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the maximum range of the L3GD20
|
|
* @returns 0 for success, -1 for invalid device, -2 if unable to set register
|
|
*/
|
|
int32_t PIOS_L3GD20_SetRange(enum pios_l3gd20_range range)
|
|
{
|
|
if(PIOS_L3GD20_Validate(dev) != 0)
|
|
return -1;
|
|
|
|
dev->range = range;
|
|
if(PIOS_L3GD20_SetReg(PIOS_L3GD20_CTRL_REG4, dev->range) != 0)
|
|
return -2;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Claim the SPI bus for the accel communications and select this chip
|
|
* @return 0 if successful, -1 for invalid device, -2 if unable to claim bus
|
|
*/
|
|
static int32_t PIOS_L3GD20_ClaimBus()
|
|
{
|
|
if(PIOS_L3GD20_Validate(dev) != 0)
|
|
return -1;
|
|
|
|
if(PIOS_SPI_ClaimBus(dev->spi_id) != 0)
|
|
return -2;
|
|
|
|
PIOS_SPI_RC_PinSet(dev->spi_id,dev->slave_num,0);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Claim the SPI bus for the accel communications and select this chip
|
|
* @return 0 if successful, -1 for invalid device, -2 if unable to claim bus
|
|
*/
|
|
static int32_t PIOS_L3GD20_ClaimBusIsr()
|
|
{
|
|
if(PIOS_L3GD20_Validate(dev) != 0)
|
|
return -1;
|
|
|
|
if(PIOS_SPI_ClaimBusISR(dev->spi_id) != 0)
|
|
return -2;
|
|
|
|
PIOS_SPI_RC_PinSet(dev->spi_id,dev->slave_num,0);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Release the SPI bus for the accel communications and end the transaction
|
|
* @return 0 if successful, -1 for invalid device
|
|
*/
|
|
int32_t PIOS_L3GD20_ReleaseBus()
|
|
{
|
|
if(PIOS_L3GD20_Validate(dev) != 0)
|
|
return -1;
|
|
|
|
PIOS_SPI_RC_PinSet(dev->spi_id,dev->slave_num,1);
|
|
|
|
return PIOS_SPI_ReleaseBus(dev->spi_id);
|
|
}
|
|
|
|
/**
|
|
* @brief Read a register from L3GD20
|
|
* @returns The register value or -1 if failure to get bus
|
|
* @param reg[in] Register address to be read
|
|
*/
|
|
static int32_t PIOS_L3GD20_GetReg(uint8_t reg)
|
|
{
|
|
uint8_t data;
|
|
|
|
if(PIOS_L3GD20_ClaimBus() != 0)
|
|
return -1;
|
|
|
|
PIOS_SPI_TransferByte(dev->spi_id,(0x80 | reg) ); // request byte
|
|
data = PIOS_SPI_TransferByte(dev->spi_id,0 ); // receive response
|
|
|
|
PIOS_L3GD20_ReleaseBus();
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* @brief Writes one byte to the L3GD20
|
|
* \param[in] reg Register address
|
|
* \param[in] data Byte to write
|
|
* \return 0 if operation was successful
|
|
* \return -1 if unable to claim SPI bus
|
|
* \return -2 if unable to claim i2c device
|
|
*/
|
|
static int32_t PIOS_L3GD20_SetReg(uint8_t reg, uint8_t data)
|
|
{
|
|
if(PIOS_L3GD20_ClaimBus() != 0)
|
|
return -1;
|
|
|
|
PIOS_SPI_TransferByte(dev->spi_id, 0x7f & reg);
|
|
PIOS_SPI_TransferByte(dev->spi_id, data);
|
|
|
|
PIOS_L3GD20_ReleaseBus();
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Read current X, Z, Y values (in that order)
|
|
* \param[out] int16_t array of size 3 to store X, Z, and Y magnetometer readings
|
|
* \returns The number of samples remaining in the fifo
|
|
*/
|
|
uint32_t l3gd20_irq = 0;
|
|
int32_t PIOS_L3GD20_ReadGyros(struct pios_l3gd20_data * data)
|
|
{
|
|
uint8_t buf[7] = {PIOS_L3GD20_GYRO_X_OUT_LSB | 0x80 | 0x40, 0, 0, 0, 0, 0, 0};
|
|
uint8_t rec[7];
|
|
|
|
if(PIOS_L3GD20_ClaimBus() != 0)
|
|
return -1;
|
|
|
|
if(PIOS_SPI_TransferBlock(dev->spi_id, &buf[0], &rec[0], sizeof(buf), NULL) < 0) {
|
|
PIOS_L3GD20_ReleaseBus();
|
|
data->gyro_x = 0;
|
|
data->gyro_y = 0;
|
|
data->gyro_z = 0;
|
|
data->temperature = 0;
|
|
return -2;
|
|
}
|
|
|
|
PIOS_L3GD20_ReleaseBus();
|
|
|
|
memcpy((uint8_t *) &(data->gyro_x), &rec[1], 6);
|
|
data->temperature = PIOS_L3GD20_GetReg(PIOS_L3GD20_OUT_TEMP);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Read the identification bytes from the MPU6050 sensor
|
|
* \return ID read from MPU6050 or -1 if failure
|
|
*/
|
|
int32_t PIOS_L3GD20_ReadID()
|
|
{
|
|
int32_t l3gd20_id = PIOS_L3GD20_GetReg(PIOS_L3GD20_WHOAMI);
|
|
if(l3gd20_id < 0)
|
|
return -1;
|
|
return l3gd20_id;
|
|
}
|
|
|
|
/**
|
|
* \brief Reads the data from the MPU6050 FIFO
|
|
* \param[out] buffer destination buffer
|
|
* \param[in] len maximum number of bytes which should be read
|
|
* \note This returns the data as X, Y, Z the temperature
|
|
* \return number of bytes transferred if operation was successful
|
|
* \return -1 if error during I2C transfer
|
|
*/
|
|
int32_t PIOS_L3GD20_ReadFifo(struct pios_l3gd20_data * buffer)
|
|
{
|
|
if(PIOS_L3GD20_Validate(dev) != 0)
|
|
return -1;
|
|
|
|
if(fifoBuf_getUsed(&dev->fifo) < sizeof(*buffer))
|
|
return -1;
|
|
|
|
fifoBuf_getData(&dev->fifo, (uint8_t *) buffer, sizeof(*buffer));
|
|
|
|
return 0;
|
|
}
|
|
|
|
float PIOS_L3GD20_GetScale()
|
|
{
|
|
if(PIOS_L3GD20_Validate(dev) != 0)
|
|
return -1;
|
|
|
|
switch (dev->range) {
|
|
case PIOS_L3GD20_SCALE_250_DEG:
|
|
return 0.00875f;
|
|
case PIOS_L3GD20_SCALE_500_DEG:
|
|
return 0.01750f;
|
|
case PIOS_L3GD20_SCALE_2000_DEG:
|
|
return 0.070f;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Run self-test operation.
|
|
* \return 0 if test succeeded
|
|
* \return non-zero value if test succeeded
|
|
*/
|
|
uint8_t PIOS_L3GD20_Test(void)
|
|
{
|
|
int32_t l3gd20_id = PIOS_L3GD20_ReadID();
|
|
if(l3gd20_id < 0)
|
|
return -1;
|
|
|
|
uint8_t id = l3gd20_id;
|
|
if(id == 0xD4)
|
|
return 0;
|
|
|
|
return -2;
|
|
}
|
|
|
|
/**
|
|
* @brief IRQ Handler. Read all the data from onboard buffer
|
|
*/
|
|
void PIOS_L3GD20_IRQHandler(void)
|
|
{
|
|
l3gd20_irq++;
|
|
|
|
struct pios_l3gd20_data data;
|
|
uint8_t buf[7] = {PIOS_L3GD20_GYRO_X_OUT_LSB | 0x80 | 0x40, 0, 0, 0, 0, 0, 0};
|
|
uint8_t rec[7];
|
|
|
|
/* This code duplicates ReadGyros above but uses ClaimBusIsr */
|
|
if(PIOS_L3GD20_ClaimBusIsr() != 0)
|
|
return;
|
|
|
|
if(PIOS_SPI_TransferBlock(dev->spi_id, &buf[0], &rec[0], sizeof(buf), NULL) < 0) {
|
|
PIOS_L3GD20_ReleaseBus();
|
|
return;
|
|
}
|
|
|
|
PIOS_L3GD20_ReleaseBus();
|
|
|
|
memcpy((uint8_t *) &(data.gyro_x), &rec[1], 6);
|
|
data.temperature = PIOS_L3GD20_GetReg(PIOS_L3GD20_OUT_TEMP);
|
|
|
|
if(fifoBuf_getFree(&dev->fifo) < sizeof(data)) {
|
|
return;
|
|
}
|
|
|
|
fifoBuf_putData(&dev->fifo, (uint8_t *) &data, sizeof(data));
|
|
}
|
|
|
|
#endif /* L3GD20 */
|
|
|
|
/**
|
|
* @}
|
|
* @}
|
|
*/
|