fly316/PX4-Autopilot
7
0
Fork 0
mirror of https://gitee.com/mirrors_PX4/PX4-Autopilot.git synced 2026-10-19 15:03:34 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
b0c3e121396d9ea04a9a37923f89bceaca3f0e8b
PX4-Autopilot/src/drivers/imu/adis16448/adis16448.cpp
T

1959 lines
47 KiB
C++
Raw Blame History

/****************************************************************************
*
* Copyright (c) 2012-2017 PX4 Development Team. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name PX4 nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
****************************************************************************/
/**
* @file adis16448.cpp
*
* Driver for the Analog device ADIS16448 connected via SPI.
*
* @author Amir Melzer
* @author Andrew Tridgell
* @author Pat Hickey
* @author Lorenz Meier <lm@inf.ethz.ch>
*
*/
#include <px4_config.h>
#include <ecl/geo/geo.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <semaphore.h>
#include <string.h>
#include <fcntl.h>
#include <poll.h>
#include <errno.h>
#include <stdio.h>
#include <math.h>
#include <unistd.h>
#include <getopt.h>
#include <perf/perf_counter.h>
#include <systemlib/err.h>
#include <systemlib/conversions.h>
#include <nuttx/arch.h>
#include <nuttx/clock.h>
#include <board_config.h>
#include <drivers/drv_hrt.h>
#include <drivers/device/spi.h>
#include <drivers/device/ringbuffer.h>
#include <drivers/device/integrator.h>
#include <board_config.h>
#include <drivers/drv_accel.h>
#include <drivers/drv_gyro.h>
#include <drivers/drv_mag.h>
#include <mathlib/math/filter/LowPassFilter2p.hpp>
#include <lib/conversion/rotation.h>
#define DIR_READ 0x00
#define DIR_WRITE 0x80
#define ADIS16448_DEVICE_PATH_ACCEL "/dev/adis16448_accel"
#define ADIS16448_DEVICE_PATH_GYRO "/dev/adis16448_gyro"
#define ADIS16448_DEVICE_PATH_MAG "/dev/adis16448_mag"
// ADIS16448 registers
#define ADIS16448_FLASH_CNT 0x00 /* Flash memory write count */
#define ADIS16448_SUPPLY_OUT 0x02 /* Power supply measurement */
#define ADIS16448_XGYRO_OUT 0x04 /* X-axis gyroscope output */
#define ADIS16448_YGYRO_OUT 0x06 /* Y-axis gyroscope output */
#define ADIS16448_ZGYRO_OUT 0x08 /* Z-axis gyroscope output */
#define ADIS16448_XACCL_OUT 0x0A /* X-axis accelerometer output */
#define ADIS16448_YACCL_OUT 0x0C /* Y-axis accelerometer output */
#define ADIS16448_ZACCL_OUT 0x0E /* Z-axis accelerometer output */
#define ADIS16448_XMAGN_OUT 0x10 /* X-axis magnetometer measurement */
#define ADIS16448_YMAGN_OUT 0x12 /* Y-axis magnetometer measurement */
#define ADIS16448_ZMAGN_OUT 0x14 /* Z-axis magnetometer measurement */
#define ADIS16448_BARO_OUT 0x16 /* Barometric pressure output */
#define ADIS16448_TEMP_OUT 0x18 /* Temperature output */
/* Calibration parameters */
#define ADIS16448_XGYRO_OFF 0x1A /* X-axis gyroscope bias offset factor */
#define ADIS16448_YGYRO_OFF 0x1C /* Y-axis gyroscope bias offset factor */
#define ADIS16448_ZGYRO_OFF 0x1E /* Z-axis gyroscope bias offset factor */
#define ADIS16448_XACCL_OFF 0x20 /* X-axis acceleration bias offset factor */
#define ADIS16448_YACCL_OFF 0x22 /* Y-axis acceleration bias offset factor */
#define ADIS16448_ZACCL_OFF 0x24 /* Z-axis acceleration bias offset factor */
#define ADIS16448_XMAGN_HIC 0x26 /* X-axis magnetometer, hard-iron factor */
#define ADIS16448_YMAGN_HIC 0x28 /* Y-axis magnetometer, hard-iron factor */
#define ADIS16448_ZMAGN_HIC 0x2A /* Z-axis magnetometer, hard-iron factor */
#define ADIS16448_XMAGN_SIC 0x2C /* X-axis magnetometer, soft-iron factor */
#define ADIS16448_YMAGN_SIC 0x2E /* Y-axis magnetometer, soft-iron factor */
#define ADIS16448_ZMAGN_SIC 0x30 /* Z-axis magnetometer, soft-iron factor */
#define ADIS16448_GPIO_CTRL 0x32 /* Auxiliary digital input/output control */
#define ADIS16448_MSC_CTRL 0x34 /* Miscellaneous control */
#define ADIS16448_SMPL_PRD 0x36 /* Internal sample period (rate) control */
#define ADIS16448_SENS_AVG 0x38 /* Dynamic range and digital filter control */
#define ADIS16448_SLP_CNT 0x3A /* Sleep mode control */
#define ADIS16448_DIAG_STAT 0x3C /* System status */
/* Alarm functions */
#define ADIS16448_GLOB_CMD 0x3E /* System command */
#define ADIS16448_ALM_MAG1 0x40 /* Alarm 1 amplitude threshold */
#define ADIS16448_ALM_MAG2 0x42 /* Alarm 2 amplitude threshold */
#define ADIS16448_ALM_SMPL1 0x44 /* Alarm 1 sample size */
#define ADIS16448_ALM_SMPL2 0x46 /* Alarm 2 sample size */
#define ADIS16448_ALM_CTRL 0x48 /* Alarm control */
#define ADIS16334_LOT_ID1 0x52 /* Lot identification code 1 */
#define ADIS16334_LOT_ID2 0x54 /* Lot identification code 2 */
#define ADIS16448_PRODUCT_ID 0x56 /* Product identifier */
#define ADIS16334_SERIAL_NUMBER 0x58 /* Serial number, lot specific */
#define ADIS16448_Product 0x4040/* Product ID Description for ADIS16448 */
#define BITS_SMPL_PRD_NO_TAP_CFG (0<<8)
#define BITS_SMPL_PRD_2_TAP_CFG (1<<8)
#define BITS_SMPL_PRD_4_TAP_CFG (2<<8)
#define BITS_SMPL_PRD_8_TAP_CFG (3<<8)
#define BITS_SMPL_PRD_16_TAP_CFG (4<<8)
#define BITS_GYRO_DYN_RANGE_1000_CFG (4<<8)
#define BITS_GYRO_DYN_RANGE_500_CFG (2<<8)
#define BITS_GYRO_DYN_RANGE_250_CFG (1<<8)
#define BITS_FIR_NO_TAP_CFG (0<<0)
#define BITS_FIR_2_TAP_CFG (1<<0)
#define BITS_FIR_4_TAP_CFG (2<<0)
#define BITS_FIR_8_TAP_CFG (3<<0)
#define BITS_FIR_16_TAP_CFG (4<<0)
#define BITS_FIR_32_TAP_CFG (5<<0)
#define BITS_FIR_64_TAP_CFG (6<<0)
#define BITS_FIR_128_TAP_CFG (7<<0)
#define ADIS16448_GYRO_DEFAULT_RATE 100
#define ADIS16448_GYRO_DEFAULT_DRIVER_FILTER_FREQ 30
#define ADIS16448_ACCEL_DEFAULT_RATE 100
#define ADIS16448_ACCEL_DEFAULT_DRIVER_FILTER_FREQ 30
#define ADIS16448_MAG_DEFAULT_RATE 100
#define ADIS16448_MAG_DEFAULT_DRIVER_FILTER_FREQ 30
#define ADIS16448_ACCEL_MAX_OUTPUT_RATE 1221
#define ADIS16448_GYRO_MAX_OUTPUT_RATE 1221
#define FW_FILTER false
#define SPI_BUS_SPEED 1000000
#define T_STALL 9
#define GYROINITIALSENSITIVITY 250
#define ACCELINITIALSENSITIVITY (1.0f / 1200.0f)
#define MAGINITIALSENSITIVITY (1.0f / 7.0f)
#define ACCELDYNAMICRANGE 18.0f
#define MAGDYNAMICRANGE 1900.0f
class ADIS16448_gyro;
class ADIS16448_mag;
class ADIS16448 : public device::SPI
{
public:
ADIS16448(int bus, const char *path_accel, const char *path_gyro, const char *path_mag, uint32_t device,
enum Rotation rotation);
virtual ~ADIS16448();
virtual int init();
virtual ssize_t read(struct file *filp, char *buffer, size_t buflen);
virtual int ioctl(struct file *filp, int cmd, unsigned long arg);
/**
* Diagnostics - print some basic information about the driver and sensor.
*/
void print_info();
void print_calibration_data();
protected:
virtual int probe();
friend class ADIS16448_gyro;
friend class ADIS16448_mag;
virtual ssize_t gyro_read(struct file *filp, char *buffer, size_t buflen);
virtual int gyro_ioctl(struct file *filp, int cmd, unsigned long arg);
virtual ssize_t mag_read(struct file *filp, char *buffer, size_t buflen);
virtual int mag_ioctl(struct file *filp, int cmd, unsigned long arg);
private:
ADIS16448_gyro *_gyro;
ADIS16448_mag *_mag;
uint16_t _product; /** product code */
struct hrt_call _call;
unsigned _call_interval;
ringbuffer::RingBuffer *_gyro_reports;
struct gyro_calibration_s _gyro_scale;
float _gyro_range_scale;
float _gyro_range_rad_s;
ringbuffer::RingBuffer *_accel_reports;
struct accel_calibration_s _accel_scale;
float _accel_range_scale;
float _accel_range_m_s2;
orb_advert_t _accel_topic;
int _accel_orb_class_instance;
int _accel_class_instance;
ringbuffer::RingBuffer *_mag_reports;
struct mag_calibration_s _mag_scale;
float _mag_range_scale;
float _mag_range_mgauss;
unsigned _sample_rate;
perf_counter_t _accel_reads;
perf_counter_t _gyro_reads;
perf_counter_t _mag_reads;
perf_counter_t _sample_perf;
perf_counter_t _bad_transfers;
math::LowPassFilter2p _gyro_filter_x;
math::LowPassFilter2p _gyro_filter_y;
math::LowPassFilter2p _gyro_filter_z;
math::LowPassFilter2p _accel_filter_x;
math::LowPassFilter2p _accel_filter_y;
math::LowPassFilter2p _accel_filter_z;
math::LowPassFilter2p _mag_filter_x;
math::LowPassFilter2p _mag_filter_y;
math::LowPassFilter2p _mag_filter_z;
Integrator _accel_int;
Integrator _gyro_int;
enum Rotation _rotation;
#pragma pack(push, 1)
/**
* Report conversation with in the ADIS16448, including command byte and interrupt status.
*/
struct ADISReport {
uint16_t cmd;
uint16_t status;
uint16_t gyro_x;
uint16_t gyro_y;
uint16_t gyro_z;
uint16_t accel_x;
uint16_t accel_y;
uint16_t accel_z;
uint16_t mag_x;
uint16_t mag_y;
uint16_t mag_z;
uint16_t baro;
uint16_t temp;
ADISReport():
cmd(0),
status(0),
gyro_x(0),
gyro_y(0),
gyro_z(0),
accel_x(0),
accel_y(0),
accel_z(0),
mag_x(0),
mag_y(0),
mag_z(0),
baro(0),
temp(0) {}
};
#pragma pack(pop)
/**
* Start automatic measurement.
*/
void start();
/**
* Stop automatic measurement.
*/
void stop();
/**
* Reset chip.
*
* Resets the chip and measurements ranges, but not scale and offset.
*/
int reset();
/**
* Static trampoline from the hrt_call context; because we don't have a
* generic hrt wrapper yet.
*
* Called by the HRT in interrupt context at the specified rate if
* automatic polling is enabled.
*
* @param arg Instance pointer for the driver that is polling.
*/
static void measure_trampoline(void *arg);
/**
* Fetch measurements from the sensor and update the report buffers.
*/
int measure();
/**
* Read a register from the ADIS16448
*
* @param The register to read.
* @return The value that was read.
*/
uint16_t read_reg16(unsigned reg);
/**
* Write a register in the ADIS16448
*
* @param reg The register to write.
* @param value The new value to write.
*/
void write_reg16(unsigned reg, uint16_t value);
/**
* Modify a register in the ADIS16448
*
* Bits are cleared before bits are set.
*
* @param reg The register to modify.
* @param clearbits Bits in the register to clear.
* @param setbits Bits in the register to set.
*/
void modify_reg16(unsigned reg, uint16_t clearbits, uint16_t setbits);
/**
* Swap a 16-bit value read from the ADIS16448 to native byte order.
*/
uint16_t swap16(uint16_t val) { return (val >> 8) | (val << 8); }
/**
* convert 12 bit integer format to int16.
*/
int16_t convert12BitToINT16(int16_t word);
/**
* Measurement self test
*
* @return 0 on success, 1 on failure
*/
int self_test();
/*
set low pass filter frequency
*/
void _set_dlpf_filter(uint16_t frequency_hz);
/*
set IMU to factory default
*/
void _set_factory_default();
/*
set sample rate (approximate) - 1kHz to 5Hz
*/
void _set_sample_rate(uint16_t desired_sample_rate_hz);
/*
set the gyroscope dynamic range
*/
void _set_gyro_dyn_range(uint16_t desired_gyro_dyn_range);
ADIS16448(const ADIS16448 &);
ADIS16448 operator=(const ADIS16448 &);
};
/**
* Helper class implementing the gyro driver node.
*/
class ADIS16448_gyro : public device::CDev
{
public:
ADIS16448_gyro(ADIS16448 *parent, const char *path);
virtual ~ADIS16448_gyro();
virtual ssize_t read(struct file *filp, char *buffer, size_t buflen);
virtual int ioctl(struct file *filp, int cmd, unsigned long arg);
virtual int init();
protected:
friend class ADIS16448;
void parent_poll_notify();
private:
ADIS16448 *_parent;
orb_advert_t _gyro_topic;
int _gyro_orb_class_instance;
int _gyro_class_instance;
/* do not allow to copy this class due to pointer data members */
ADIS16448_gyro(const ADIS16448_gyro &);
ADIS16448_gyro operator=(const ADIS16448_gyro &);
};
/**
* Helper class implementing the mag driver node.
*/
class ADIS16448_mag : public device::CDev
{
public:
ADIS16448_mag(ADIS16448 *parent, const char *path);
virtual ~ADIS16448_mag();
virtual ssize_t read(struct file *filp, char *buffer, size_t buflen);
virtual int ioctl(struct file *filp, int cmd, unsigned long arg);
virtual int init();
protected:
friend class ADIS16448;
void parent_poll_notify();
private:
ADIS16448 *_parent;
orb_advert_t _mag_topic;
int _mag_orb_class_instance;
int _mag_class_instance;
/* do not allow to copy this class due to pointer data members */
ADIS16448_mag(const ADIS16448_mag &);
ADIS16448_mag operator=(const ADIS16448_mag &);
};
/** driver 'main' command */
extern "C" { __EXPORT int adis16448_main(int argc, char *argv[]); }
ADIS16448::ADIS16448(int bus, const char *path_accel, const char *path_gyro, const char *path_mag, uint32_t device,
enum Rotation rotation) :
SPI("ADIS16448", path_accel, bus, device, SPIDEV_MODE3, SPI_BUS_SPEED),
_gyro(new ADIS16448_gyro(this, path_gyro)),
_mag(new ADIS16448_mag(this, path_mag)),
_product(0),
_call{},
_call_interval(0),
_gyro_reports(nullptr),
_gyro_scale{},
_gyro_range_scale(0.0f),
_gyro_range_rad_s(0.0f),
_accel_reports(nullptr),
_accel_scale{},
_accel_range_scale(0.0f),
_accel_range_m_s2(0.0f),
_accel_topic(nullptr),
_accel_orb_class_instance(-1),
_accel_class_instance(-1),
_mag_reports(nullptr),
_mag_scale{},
_mag_range_scale(0.0f),
_mag_range_mgauss(0.0f),
_sample_rate(100), /* Init sampling frequency set to 100Hz */
_accel_reads(perf_alloc(PC_COUNT, "adis16448_accel_read")),
_gyro_reads(perf_alloc(PC_COUNT, "adis16448_gyro_read")),
_mag_reads(perf_alloc(PC_COUNT, "adis16448_mag_read")),
_sample_perf(perf_alloc(PC_ELAPSED, "adis16448_read")),
_bad_transfers(perf_alloc(PC_COUNT, "adis16448_bad_transfers")),
_gyro_filter_x(ADIS16448_GYRO_DEFAULT_RATE, ADIS16448_GYRO_DEFAULT_DRIVER_FILTER_FREQ),
_gyro_filter_y(ADIS16448_GYRO_DEFAULT_RATE, ADIS16448_GYRO_DEFAULT_DRIVER_FILTER_FREQ),
_gyro_filter_z(ADIS16448_GYRO_DEFAULT_RATE, ADIS16448_GYRO_DEFAULT_DRIVER_FILTER_FREQ),
_accel_filter_x(ADIS16448_ACCEL_DEFAULT_RATE, ADIS16448_ACCEL_DEFAULT_DRIVER_FILTER_FREQ),
_accel_filter_y(ADIS16448_ACCEL_DEFAULT_RATE, ADIS16448_ACCEL_DEFAULT_DRIVER_FILTER_FREQ),
_accel_filter_z(ADIS16448_ACCEL_DEFAULT_RATE, ADIS16448_ACCEL_DEFAULT_DRIVER_FILTER_FREQ),
_mag_filter_x(ADIS16448_MAG_DEFAULT_RATE, ADIS16448_MAG_DEFAULT_DRIVER_FILTER_FREQ),
_mag_filter_y(ADIS16448_MAG_DEFAULT_RATE, ADIS16448_MAG_DEFAULT_DRIVER_FILTER_FREQ),
_mag_filter_z(ADIS16448_MAG_DEFAULT_RATE, ADIS16448_MAG_DEFAULT_DRIVER_FILTER_FREQ),
_accel_int(1000000 / ADIS16448_ACCEL_MAX_OUTPUT_RATE, false),
_gyro_int(1000000 / ADIS16448_GYRO_MAX_OUTPUT_RATE, true),
_rotation(rotation)
{
// disable debug() calls
_debug_enabled = false;
_device_id.devid_s.devtype = DRV_ACC_DEVTYPE_ADIS16448;
_gyro->_device_id.devid = _device_id.devid;
_gyro->_device_id.devid_s.devtype = DRV_GYR_DEVTYPE_ADIS16448;
_mag->_device_id.devid = _device_id.devid;
_mag->_device_id.devid_s.devtype = DRV_MAG_DEVTYPE_ADIS16448;
// default gyro scale factors
_gyro_scale.x_offset = 0;
_gyro_scale.x_scale = 1.0f;
_gyro_scale.y_offset = 0;
_gyro_scale.y_scale = 1.0f;
_gyro_scale.z_offset = 0;
_gyro_scale.z_scale = 1.0f;
// default accel scale factors
_accel_scale.x_offset = 0;
_accel_scale.x_scale = 1.0f;
_accel_scale.y_offset = 0;
_accel_scale.y_scale = 1.0f;
_accel_scale.z_offset = 0;
_accel_scale.z_scale = 1.0f;
// default mag scale factors
_mag_scale.x_offset = 0;
_mag_scale.x_scale = 1.0f;
_mag_scale.y_offset = 0;
_mag_scale.y_scale = 1.0f;
_mag_scale.z_offset = 0;
_mag_scale.z_scale = 1.0f;
memset(&_call, 0, sizeof(_call));
}
ADIS16448::~ADIS16448()
{
/* make sure we are truly inactive */
stop();
/* delete the gyro subdriver */
delete _gyro;
delete _mag;
/* free any existing reports */
if (_gyro_reports != nullptr) {
delete _gyro_reports;
}
if (_accel_reports != nullptr) {
delete _accel_reports;
}
if (_mag_reports != nullptr) {
delete _mag_reports;
}
if (_accel_class_instance != -1) {
unregister_class_devname(ACCEL_BASE_DEVICE_PATH, _accel_class_instance);
}
/* delete the perf counter */
perf_free(_sample_perf);
perf_free(_accel_reads);
perf_free(_gyro_reads);
perf_free(_mag_reads);
perf_free(_bad_transfers);
}
int
ADIS16448::init()
{
int ret;
/* do SPI init (and probe) first */
ret = SPI::init();
/* if probe/setup failed, bail now */
if (ret != OK) {
DEVICE_DEBUG("SPI setup failed");
return ret;
}
/* allocate basic report buffers */
_gyro_reports = new ringbuffer::RingBuffer(2, sizeof(gyro_report));
if (_gyro_reports == nullptr) {
goto out;
}
_accel_reports = new ringbuffer::RingBuffer(2, sizeof(accel_report));
if (_accel_reports == nullptr) {
goto out;
}
_mag_reports = new ringbuffer::RingBuffer(2, sizeof(mag_report));
if (_mag_reports == nullptr) {
goto out;
}
if (reset() != OK) {
goto out;
}
/* Initialize offsets and scales */
_gyro_scale.x_offset = 0;
_gyro_scale.x_scale = 1.0f;
_gyro_scale.y_offset = 0;
_gyro_scale.y_scale = 1.0f;
_gyro_scale.z_offset = 0;
_gyro_scale.z_scale = 1.0f;
_accel_scale.x_offset = 0;
_accel_scale.x_scale = 1.0f;
_accel_scale.y_offset = 0;
_accel_scale.y_scale = 1.0f;
_accel_scale.z_offset = 0;
_accel_scale.z_scale = 1.0f;
_mag_scale.x_offset = 0;
_mag_scale.x_scale = 1.0f;
_mag_scale.y_offset = 0;
_mag_scale.y_scale = 1.0f;
_mag_scale.z_offset = 0;
_mag_scale.z_scale = 1.0f;
/* do CDev init for the gyro device node, keep it optional */
ret = _gyro->init();
/* if probe/setup failed, bail now */
if (ret != OK) {
DEVICE_DEBUG("gyro init failed");
return ret;
}
/* do CDev init for the gyro device node, keep it optional */
ret = _mag->init();
/* if probe/setup failed, bail now */
if (ret != OK) {
DEVICE_DEBUG("mag init failed");
return ret;
}
_accel_class_instance = register_class_devname(ACCEL_BASE_DEVICE_PATH);
/* fetch an initial set of measurements for advertisement */
measure();
/* advertise sensor topic, measure manually to initialize valid report */
struct accel_report arp;
_accel_reports->get(&arp);
/* measurement will have generated a report, publish */
_accel_topic = orb_advertise_multi(ORB_ID(sensor_accel), &arp,
&_accel_orb_class_instance, ORB_PRIO_MAX);
if (_accel_topic == nullptr) {
warnx("ADVERT FAIL");
}
struct gyro_report grp;
_gyro_reports->get(&grp);
_gyro->_gyro_topic = orb_advertise_multi(ORB_ID(sensor_gyro), &grp,
&_gyro->_gyro_orb_class_instance, ORB_PRIO_MAX);
if (_gyro->_gyro_topic == nullptr) {
warnx("ADVERT FAIL");
}
struct mag_report mrp;
_mag_reports->get(&mrp);
_mag->_mag_topic = orb_advertise_multi(ORB_ID(sensor_mag), &mrp,
&_mag->_mag_orb_class_instance, ORB_PRIO_MAX);
if (_mag->_mag_topic == nullptr) {
warnx("ADVERT FAIL");
}
out:
return ret;
}
int ADIS16448::reset()
{
/* Set gyroscope scale to default value */
_set_gyro_dyn_range(GYROINITIALSENSITIVITY);
/* Set digital FIR filter tap */
_set_dlpf_filter(BITS_FIR_16_TAP_CFG);
/* Set IMU sample rate */
_set_sample_rate(_sample_rate);
_accel_range_scale = CONSTANTS_ONE_G * ACCELINITIALSENSITIVITY;
_accel_range_m_s2 = CONSTANTS_ONE_G * ACCELDYNAMICRANGE;
_mag_range_scale = MAGINITIALSENSITIVITY;
_mag_range_mgauss = MAGDYNAMICRANGE;
/* settling time */
up_udelay(50000);
return OK;
}
int
ADIS16448::probe()
{
uint16_t serial_number;
/* retry 5 time to get the ADIS16448 PRODUCT ID number */
for (int i = 0; i < 5; i++) {
/* recognize product ID */
_product = read_reg16(ADIS16448_PRODUCT_ID);
if (_product != 0) {
break;
}
}
/* recognize product serial number */
serial_number = (read_reg16(ADIS16334_SERIAL_NUMBER) & 0xfff);
/* verify product ID */
switch (_product) {
case ADIS16448_Product:
DEVICE_DEBUG("ADIS16448 is detected ID: 0x%02x, Serial: 0x%02x", _product, serial_number);
modify_reg16(ADIS16448_GPIO_CTRL, 0x0200, 0x0002); /* Turn on ADIS16448 adaptor board led */
return OK;
}
DEVICE_DEBUG("unexpected ID 0x%02x", _product);
return -EIO;
}
/* set sample rate for both accel and gyro */
void
ADIS16448::_set_sample_rate(uint16_t desired_sample_rate_hz)
{
uint16_t smpl_prd = 0;
if (desired_sample_rate_hz <= 51) {
smpl_prd = BITS_SMPL_PRD_16_TAP_CFG;
} else if (desired_sample_rate_hz <= 102) {
smpl_prd = BITS_SMPL_PRD_8_TAP_CFG;
} else if (desired_sample_rate_hz <= 204) {
smpl_prd = BITS_SMPL_PRD_4_TAP_CFG;
} else if (desired_sample_rate_hz <= 409) {
smpl_prd = BITS_SMPL_PRD_2_TAP_CFG;
} else {
smpl_prd = BITS_SMPL_PRD_NO_TAP_CFG;
}
modify_reg16(ADIS16448_SMPL_PRD, 0x1f00, smpl_prd);
if ((read_reg16(ADIS16448_SMPL_PRD) & 0x1f00) != smpl_prd) {
DEVICE_DEBUG("failed to set IMU sample rate");
}
}
/* set the DLPF FIR filter tap. This affects both accelerometer and gyroscope. */
void
ADIS16448::_set_dlpf_filter(uint16_t desired_filter_tap)
{
modify_reg16(ADIS16448_SENS_AVG, 0x0007, desired_filter_tap);
/* Verify data write on the IMU */
if ((read_reg16(ADIS16448_SENS_AVG) & 0x0007) != desired_filter_tap) {
DEVICE_DEBUG("failed to set IMU filter");
}
}
/* set IMU to factory defaults. */
void
ADIS16448::_set_factory_default()
{
write_reg16(ADIS16448_GLOB_CMD, 0x02);
}
/* set the gyroscope dynamic range */
void
ADIS16448::_set_gyro_dyn_range(uint16_t desired_gyro_dyn_range)
{
uint16_t gyro_range_selection = 0;
if (desired_gyro_dyn_range <= 250) {
gyro_range_selection = BITS_GYRO_DYN_RANGE_250_CFG;
} else if (desired_gyro_dyn_range <= 500) {
gyro_range_selection = BITS_GYRO_DYN_RANGE_500_CFG;
} else {
gyro_range_selection = BITS_GYRO_DYN_RANGE_1000_CFG;
}
modify_reg16(ADIS16448_SENS_AVG, 0x0700, gyro_range_selection);
/* Verify data write on the IMU */
if ((read_reg16(ADIS16448_SENS_AVG) & 0x0700) != gyro_range_selection) {
DEVICE_DEBUG("failed to set gyro range");
} else {
_gyro_range_rad_s = ((float)(gyro_range_selection >> 8) * 250.0f / 180.0f) * M_PI_F;
_gyro_range_scale = (float)(gyro_range_selection >> 8) / 100.0f;
}
}
ssize_t
ADIS16448::read(struct file *filp, char *buffer, size_t buflen)
{
unsigned count = buflen / sizeof(accel_report);
/* buffer must be large enough */
if (count < 1) {
return -ENOSPC;
}
/* if automatic measurement is not enabled, get a fresh measurement into the buffer */
if (_call_interval == 0) {
_accel_reports->flush();
measure();
}
/* if no data, error (we could block here) */
if (_accel_reports->empty()) {
return -EAGAIN;
}
perf_count(_accel_reads);
/* copy reports out of our buffer to the caller */
accel_report *arp = reinterpret_cast<accel_report *>(buffer);
int transferred = 0;
while (count--) {
if (!_accel_reports->get(arp)) {
break;
}
transferred++;
arp++;
}
/* return the number of bytes transferred */
return (transferred * sizeof(accel_report));
}
int
ADIS16448::self_test()
{
if (perf_event_count(_sample_perf) == 0) {
measure();
}
/* return 0 on success, 1 else */
return (perf_event_count(_sample_perf) > 0) ? 0 : 1;
}
ssize_t
ADIS16448::gyro_read(struct file *filp, char *buffer, size_t buflen)
{
unsigned count = buflen / sizeof(gyro_report);
/* buffer must be large enough */
if (count < 1) {
return -ENOSPC;
}
/* if automatic measurement is not enabled, get a fresh measurement into the buffer */
if (_call_interval == 0) {
_gyro_reports->flush();
measure();
}
/* if no data, error (we could block here) */
if (_gyro_reports->empty()) {
return -EAGAIN;
}
perf_count(_gyro_reads);
/* copy reports out of our buffer to the caller */
gyro_report *grp = reinterpret_cast<gyro_report *>(buffer);
int transferred = 0;
while (count--) {
if (!_gyro_reports->get(grp)) {
break;
}
transferred++;
grp++;
}
/* return the number of bytes transferred */
return (transferred * sizeof(gyro_report));
}
ssize_t
ADIS16448::mag_read(struct file *filp, char *buffer, size_t buflen)
{
unsigned count = buflen / sizeof(mag_report);
/* buffer must be large enough */
if (count < 1) {
return -ENOSPC;
}
/* if automatic measurement is not enabled, get a fresh measurement into the buffer */
if (_call_interval == 0) {
_mag_reports->flush();
measure();
}
/* if no data, error (we could block here) */
if (_mag_reports->empty()) {
return -EAGAIN;
}
perf_count(_mag_reads);
/* copy reports out of our buffer to the caller */
mag_report *mrp = reinterpret_cast<mag_report *>(buffer);
int transferred = 0;
while (count--) {
if (!_mag_reports->get(mrp)) {
break;
}
transferred++;
mrp++;
}
/* return the number of bytes transferred */
return (transferred * sizeof(mag_report));
}
int
ADIS16448::ioctl(struct file *filp, int cmd, unsigned long arg)
{
switch (cmd) {
case SENSORIOCRESET:
return reset();
case SENSORIOCSPOLLRATE: {
switch (arg) {
/* switching to manual polling */
case SENSOR_POLLRATE_MANUAL:
stop();
_call_interval = 0;
return OK;
/* zero would be bad */
case 0:
return -EINVAL;
/* set default/max polling rate */
case SENSOR_POLLRATE_MAX:
return ioctl(filp, SENSORIOCSPOLLRATE, 1000);
case SENSOR_POLLRATE_DEFAULT:
return ioctl(filp, SENSORIOCSPOLLRATE, ADIS16448_ACCEL_DEFAULT_RATE);
/* adjust to a legal polling interval in Hz */
default: {
/* do we need to start internal polling? */
bool want_start = (_call_interval == 0);
/* convert hz to hrt interval via microseconds */
unsigned ticks = 1000000 / arg;
/* check against maximum sane rate */
if (ticks < 1000) {
return -EINVAL;
}
// adjust filters
float cutoff_freq_hz = _accel_filter_x.get_cutoff_freq();
float sample_rate = 1.0e6f / ticks;
_accel_filter_x.set_cutoff_frequency(sample_rate, cutoff_freq_hz);
_accel_filter_y.set_cutoff_frequency(sample_rate, cutoff_freq_hz);
_accel_filter_z.set_cutoff_frequency(sample_rate, cutoff_freq_hz);
float cutoff_freq_hz_gyro = _gyro_filter_x.get_cutoff_freq();
_gyro_filter_x.set_cutoff_frequency(sample_rate, cutoff_freq_hz_gyro);
_gyro_filter_y.set_cutoff_frequency(sample_rate, cutoff_freq_hz_gyro);
_gyro_filter_z.set_cutoff_frequency(sample_rate, cutoff_freq_hz_gyro);
float cutoff_freq_hz_mag = _mag_filter_x.get_cutoff_freq();
_mag_filter_x.set_cutoff_frequency(sample_rate, cutoff_freq_hz_mag);
_mag_filter_y.set_cutoff_frequency(sample_rate, cutoff_freq_hz_mag);
_mag_filter_z.set_cutoff_frequency(sample_rate, cutoff_freq_hz_mag);
/* update interval for next measurement */
/* XXX this is a bit shady, but no other way to adjust... */
_call.period = _call_interval = ticks;
/* if we need to start the poll state machine, do it */
if (want_start) {
start();
}
return OK;
}
}
}
case SENSORIOCGPOLLRATE:
if (_call_interval == 0) {
return SENSOR_POLLRATE_MANUAL;
}
return 1000000 / _call_interval;
case SENSORIOCSQUEUEDEPTH: {
/* lower bound is mandatory, upper bound is a sanity check */
if ((arg < 1) || (arg > 100)) {
return -EINVAL;
}
irqstate_t flags = px4_enter_critical_section();
if (!_accel_reports->resize(arg)) {
px4_leave_critical_section(flags);
return -ENOMEM;
}
px4_leave_critical_section(flags);
return OK;
}
case ACCELIOCSSAMPLERATE:
_set_sample_rate(arg);
return OK;
case ACCELIOCSSCALE: {
/* copy scale, but only if off by a few percent */
struct accel_calibration_s *s = (struct accel_calibration_s *) arg;
float sum = s->x_scale + s->y_scale + s->z_scale;
if (sum > 2.0f && sum < 4.0f) {
memcpy(&_accel_scale, s, sizeof(_accel_scale));
return OK;
} else {
return -EINVAL;
}
}
case ACCELIOCSRANGE:
return -EINVAL;
case ACCELIOCGRANGE:
return (unsigned long)((_accel_range_m_s2) / CONSTANTS_ONE_G + 0.5f);
case ACCELIOCTYPE:
return (ADIS16448_Product);
default:
/* give it to the superclass */
return SPI::ioctl(filp, cmd, arg);
}
}
int
ADIS16448::gyro_ioctl(struct file *filp, int cmd, unsigned long arg)
{
switch (cmd) {
/* these are shared with the accel side */
case SENSORIOCSPOLLRATE:
case SENSORIOCGPOLLRATE:
case SENSORIOCRESET:
return ioctl(filp, cmd, arg);
case SENSORIOCSQUEUEDEPTH: {
/* lower bound is mandatory, upper bound is a sanity check */
if ((arg < 1) || (arg > 100)) {
return -EINVAL;
}
irqstate_t flags = px4_enter_critical_section();
if (!_gyro_reports->resize(arg)) {
px4_leave_critical_section(flags);
return -ENOMEM;
}
px4_leave_critical_section(flags);
return OK;
}
case GYROIOCGSAMPLERATE:
return _sample_rate;
case GYROIOCSSAMPLERATE:
_set_sample_rate(arg);
return OK;
case GYROIOCSSCALE:
/* copy scale in */
memcpy(&_gyro_scale, (struct gyro_calibration_s *) arg, sizeof(_gyro_scale));
return OK;
case GYROIOCGSCALE:
/* copy scale out */
memcpy((struct gyro_calibration_s *) arg, &_gyro_scale, sizeof(_gyro_scale));
return OK;
case GYROIOCSRANGE:
_set_gyro_dyn_range(arg);
return OK;
case GYROIOCGRANGE:
return (unsigned long)(_gyro_range_rad_s * 180.0f / M_PI_F + 0.5f);
case GYROIOCTYPE:
return (ADIS16448_Product);
default:
/* give it to the superclass */
return SPI::ioctl(filp, cmd, arg);
}
}
int
ADIS16448::mag_ioctl(struct file *filp, int cmd, unsigned long arg)
{
switch (cmd) {
/* these are shared with the accel side */
case SENSORIOCSPOLLRATE:
case SENSORIOCGPOLLRATE:
case SENSORIOCRESET:
return ioctl(filp, cmd, arg);
case SENSORIOCSQUEUEDEPTH: {
/* lower bound is mandatory, upper bound is a sanity check */
if ((arg < 1) || (arg > 100)) {
return -EINVAL;
}
irqstate_t flags = px4_enter_critical_section();
if (!_mag_reports->resize(arg)) {
px4_leave_critical_section(flags);
return -ENOMEM;
}
px4_leave_critical_section(flags);
return OK;
}
case MAGIOCGSAMPLERATE:
return _sample_rate;
case MAGIOCSSAMPLERATE:
_set_sample_rate(arg);
return OK;
case MAGIOCSSCALE:
/* copy scale in */
memcpy(&_mag_scale, (struct mag_calibration_s *) arg, sizeof(_mag_scale));
return OK;
case MAGIOCGSCALE:
/* copy scale out */
memcpy((struct mag_calibration_s *) arg, &_mag_scale, sizeof(_mag_scale));
return OK;
case MAGIOCGRANGE:
return (unsigned long)(_mag_range_mgauss);
case MAGIOCTYPE:
return (ADIS16448_Product);
default:
/* give it to the superclass */
return SPI::ioctl(filp, cmd, arg);
}
}
uint16_t
ADIS16448::read_reg16(unsigned reg)
{
uint16_t cmd[1];
cmd[0] = ((reg | DIR_READ) << 8) & 0xff00;
transferhword(cmd, nullptr, 1);
up_udelay(T_STALL);
transferhword(nullptr, cmd, 1);
up_udelay(T_STALL);
return cmd[0];
}
void
ADIS16448::write_reg16(unsigned reg, uint16_t value)
{
uint16_t cmd[2];
cmd[0] = ((reg | DIR_WRITE) << 8) | (0x00ff & value);
cmd[1] = (((reg + 0x1) | DIR_WRITE) << 8) | ((0xff00 & value) >> 8);
transferhword(cmd, nullptr, 1);
up_udelay(T_STALL);
transferhword(cmd + 1, nullptr, 1);
up_udelay(T_STALL);
}
void
ADIS16448::modify_reg16(unsigned reg, uint16_t clearbits, uint16_t setbits)
{
uint16_t val;
val = read_reg16(reg);
val &= ~clearbits;
val |= setbits;
write_reg16(reg, val);
}
int16_t
ADIS16448::convert12BitToINT16(int16_t word)
{
int16_t outputbuffer = 0;
if ((word >> 11) & 0x1) {
outputbuffer = (word & 0xfff) | 0xf000;
} else {
outputbuffer = (word & 0x0fff);
}
return (outputbuffer);
}
void
ADIS16448::start()
{
/* make sure we are stopped first */
uint32_t last_call_interval = _call_interval;
stop();
_call_interval = last_call_interval;
/* discard any stale data in the buffers */
_gyro_reports->flush();
_accel_reports->flush();
_mag_reports->flush();
/* start polling at the specified rate */
hrt_call_every(&_call, 1000, _call_interval, (hrt_callout)&ADIS16448::measure_trampoline, this);
}
void
ADIS16448::stop()
{
hrt_cancel(&_call);
}
void
ADIS16448::measure_trampoline(void *arg)
{
ADIS16448 *dev = reinterpret_cast<ADIS16448 *>(arg);
/* make another measurement */
dev->measure();
}
int
ADIS16448::measure()
{
struct ADISReport adis_report;
struct Report {
int16_t gyro_x;
int16_t gyro_y;
int16_t gyro_z;
int16_t accel_x;
int16_t accel_y;
int16_t accel_z;
int16_t mag_x;
int16_t mag_y;
int16_t mag_z;
int16_t baro;
int16_t temp;
} report;
/* start measuring */
perf_begin(_sample_perf);
/*
* Fetch the full set of measurements from the ADIS16448 in one pass (burst read).
*/
adis_report.cmd = ((ADIS16448_GLOB_CMD | DIR_READ) << 8) & 0xff00;
if (OK != transferhword((uint16_t *)&adis_report, ((uint16_t *)&adis_report), sizeof(adis_report) / sizeof(uint16_t))) {
return -EIO;
}
report.gyro_x = (int16_t) adis_report.gyro_x;
report.gyro_y = (int16_t) adis_report.gyro_y;
report.gyro_z = (int16_t) adis_report.gyro_z;
report.accel_x = (int16_t) adis_report.accel_x;
report.accel_y = (int16_t) adis_report.accel_y;
report.accel_z = (int16_t) adis_report.accel_z;
report.mag_x = (int16_t) adis_report.mag_x;
report.mag_y = (int16_t) adis_report.mag_y;
report.mag_z = (int16_t) adis_report.mag_z;
report.baro = (int16_t) adis_report.baro;
report.temp = convert12BitToINT16(adis_report.temp);
if (report.gyro_x == 0 && report.gyro_y == 0 && report.gyro_z == 0 &&
report.accel_x == 0 && report.accel_y == 0 && report.accel_z == 0 &&
report.mag_x == 0 && report.mag_y == 0 && report.mag_z == 0 &&
report.baro == 0 && report.temp == 0) {
perf_count(_bad_transfers);
perf_end(_sample_perf);
return -EIO;
}
/*
* Report buffers.
*/
accel_report arb;
gyro_report grb;
mag_report mrb;
grb.timestamp = arb.timestamp = mrb.timestamp = hrt_absolute_time();
grb.error_count = arb.error_count = mrb.error_count = perf_event_count(_bad_transfers);
/* Gyro report: */
grb.x_raw = report.gyro_x;
grb.y_raw = report.gyro_y;
grb.z_raw = report.gyro_z;
float xraw_f = report.gyro_x;
float yraw_f = report.gyro_y;
float zraw_f = report.gyro_z;
// apply user specified rotation
rotate_3f(_rotation, xraw_f, yraw_f, zraw_f);
float x_gyro_in_new = ((xraw_f * _gyro_range_scale) * M_PI_F / 180.0f - _gyro_scale.x_offset) * _gyro_scale.x_scale;
float y_gyro_in_new = ((yraw_f * _gyro_range_scale) * M_PI_F / 180.0f - _gyro_scale.y_offset) * _gyro_scale.y_scale;
float z_gyro_in_new = ((zraw_f * _gyro_range_scale) * M_PI_F / 180.0f - _gyro_scale.z_offset) * _gyro_scale.z_scale;
if (FW_FILTER) {
grb.x = _gyro_filter_x.apply(x_gyro_in_new);
grb.y = _gyro_filter_y.apply(y_gyro_in_new);
grb.z = _gyro_filter_z.apply(z_gyro_in_new);
} else {
grb.x = x_gyro_in_new;
grb.y = y_gyro_in_new;
grb.z = z_gyro_in_new;
}
grb.scaling = _gyro_range_scale * M_PI_F / 180.0f;
/* Accel report: */
arb.x_raw = report.accel_x;
arb.y_raw = report.accel_y;
arb.z_raw = report.accel_z;
xraw_f = report.accel_x;
yraw_f = report.accel_y;
zraw_f = report.accel_z;
// apply user specified rotation
rotate_3f(_rotation, xraw_f, yraw_f, zraw_f);
float x_in_new = ((xraw_f * _accel_range_scale) - _accel_scale.x_offset) * _accel_scale.x_scale;
float y_in_new = ((yraw_f * _accel_range_scale) - _accel_scale.y_offset) * _accel_scale.y_scale;
float z_in_new = ((zraw_f * _accel_range_scale) - _accel_scale.z_offset) * _accel_scale.z_scale;
if (FW_FILTER) {
arb.x = _accel_filter_x.apply(x_in_new);
arb.y = _accel_filter_y.apply(y_in_new);
arb.z = _accel_filter_z.apply(z_in_new);
} else {
arb.x = x_in_new;
arb.y = y_in_new;
arb.z = z_in_new;
}
arb.scaling = _accel_range_scale;
/* Mag report: */
mrb.x_raw = report.mag_x;
mrb.y_raw = report.mag_y;
mrb.z_raw = report.mag_z;
xraw_f = report.mag_x;
yraw_f = report.mag_y;
zraw_f = report.mag_z;
// apply user specified rotation
rotate_3f(_rotation, xraw_f, yraw_f, zraw_f);
float x_mag_new = ((xraw_f * _mag_range_scale) - _mag_scale.x_offset) * _mag_scale.x_scale;
float y_mag_new = ((yraw_f * _mag_range_scale) - _mag_scale.y_offset) * _mag_scale.y_scale;
float z_mag_new = ((zraw_f * _mag_range_scale) - _mag_scale.z_offset) * _mag_scale.z_scale;
if (FW_FILTER) {
mrb.x = _mag_filter_x.apply(x_mag_new) / 1000.0f;
mrb.y = _mag_filter_y.apply(y_mag_new) / 1000.0f;
mrb.z = _mag_filter_z.apply(z_mag_new) / 1000.0f;
} else {
mrb.x = x_mag_new / 1000.0f;
mrb.y = y_mag_new / 1000.0f;
mrb.z = z_mag_new / 1000.0f;
}
mrb.scaling = _mag_range_scale / 1000.0f;
/* Temperature report: */
grb.temperature = (report.temp * 0.07386f) + 31.0f;
arb.temperature = grb.temperature;
matrix::Vector3f aval(x_in_new, y_in_new, z_in_new);
matrix::Vector3f aval_integrated;
bool accel_notify = _accel_int.put(arb.timestamp, aval, aval_integrated, arb.integral_dt);
arb.x_integral = aval_integrated(0);
arb.y_integral = aval_integrated(1);
arb.z_integral = aval_integrated(2);
matrix::Vector3f gval(x_gyro_in_new, y_gyro_in_new, z_gyro_in_new);
matrix::Vector3f gval_integrated;
bool gyro_notify = _gyro_int.put(grb.timestamp, gval, gval_integrated, grb.integral_dt);
grb.x_integral = gval_integrated(0);
grb.y_integral = gval_integrated(1);
grb.z_integral = gval_integrated(2);
/* return device ID */
arb.device_id = _device_id.devid;
grb.device_id = _gyro->_device_id.devid;
mrb.device_id = _mag->_device_id.devid;
_gyro_reports ->force(&grb);
_accel_reports->force(&arb);
_mag_reports ->force(&mrb);
/* notify anyone waiting for data */
if (accel_notify) {
poll_notify(POLLIN);
}
if (gyro_notify) {
_gyro->parent_poll_notify();
}
_mag->parent_poll_notify();
if (accel_notify && !(_pub_blocked)) {
/* publish it */
orb_publish(ORB_ID(sensor_accel), _accel_topic, &arb);
}
if (gyro_notify && !(_pub_blocked)) {
/* publish it */
orb_publish(ORB_ID(sensor_gyro), _gyro->_gyro_topic, &grb);
}
if (!(_pub_blocked) && ((adis_report.status >> 7) & 0x1)) { /* Mag data validity bit (bit 8 DIAG_STAT) */
/* publish it */
orb_publish(ORB_ID(sensor_mag), _mag->_mag_topic, &mrb);
}
/* stop measuring */
perf_end(_sample_perf);
return OK;
}
void
ADIS16448::print_calibration_data()
{
uint16_t XGYRO_OFF = read_reg16(ADIS16448_XGYRO_OFF);
uint16_t YGYRO_OFF = read_reg16(ADIS16448_YGYRO_OFF);
uint16_t ZGYRO_OFF = read_reg16(ADIS16448_ZGYRO_OFF);
uint16_t XACCL_OFF = read_reg16(ADIS16448_XACCL_OFF);
uint16_t YACCL_OFF = read_reg16(ADIS16448_YACCL_OFF);
uint16_t ZACCL_OFF = read_reg16(ADIS16448_ZACCL_OFF);
uint16_t XMAGN_HIC = read_reg16(ADIS16448_XMAGN_HIC);
uint16_t YMAGN_HIC = read_reg16(ADIS16448_YMAGN_HIC);
uint16_t ZMAGN_HIC = read_reg16(ADIS16448_ZMAGN_HIC);
uint16_t XMAGN_SIC = read_reg16(ADIS16448_XMAGN_SIC);
uint16_t YMAGN_SIC = read_reg16(ADIS16448_YMAGN_SIC);
uint16_t ZMAGN_SIC = read_reg16(ADIS16448_ZMAGN_SIC);
warnx("single calibration value read:");
warnx("XGYRO_OFF =: \t%8.4x\t", XGYRO_OFF);
warnx("YGYRO_OFF =: \t%8.4x\t", YGYRO_OFF);
warnx("ZGYRO_OFF =: \t%8.4x\t", ZGYRO_OFF);
warnx("XACCL_OFF =: \t%8.4x\t", XACCL_OFF);
warnx("YACCL_OFF =: \t%8.4x\t", YACCL_OFF);
warnx("ZACCL_OFF =: \t%8.4x\t", ZACCL_OFF);
warnx("XMAGN_HIC =: \t%8.4x\t", XMAGN_HIC);
warnx("YMAGN_HIC =: \t%8.4x\t", YMAGN_HIC);
warnx("ZMAGN_HIC =: \t%8.4x\t", ZMAGN_HIC);
warnx("XMAGN_SIC =: \t%8.4x\t", XMAGN_SIC);
warnx("YMAGN_SIC =: \t%8.4x\t", YMAGN_SIC);
warnx("ZMAGN_SIC =: \t%8.4x\t", ZMAGN_SIC);
}
void
ADIS16448::print_info()
{
perf_print_counter(_sample_perf);
perf_print_counter(_accel_reads);
perf_print_counter(_gyro_reads);
perf_print_counter(_mag_reads);
perf_print_counter(_bad_transfers);
_accel_reports->print_info("accel queue");
_gyro_reports->print_info("gyro queue");
_mag_reports->print_info("mag queue");
printf("DEVICE ID:\nACCEL:\t%d\nGYRO:\t%d\nMAG:\t%d\n", _device_id.devid, _gyro->_device_id.devid,
_mag->_device_id.devid);
}
ADIS16448_gyro::ADIS16448_gyro(ADIS16448 *parent, const char *path) :
CDev("ADIS16448_gyro", path),
_parent(parent),
_gyro_topic(nullptr),
_gyro_orb_class_instance(-1),
_gyro_class_instance(-1)
{
}
ADIS16448_gyro::~ADIS16448_gyro()
{
if (_gyro_class_instance != -1) {
unregister_class_devname(GYRO_BASE_DEVICE_PATH, _gyro_class_instance);
}
}
int
ADIS16448_gyro::init()
{
int ret;
// do base class init
ret = CDev::init();
/* if probe/setup failed, bail now */
if (ret != OK) {
DEVICE_DEBUG("gyro init failed");
return ret;
}
_gyro_class_instance = register_class_devname(GYRO_BASE_DEVICE_PATH);
return ret;
}
void
ADIS16448_gyro::parent_poll_notify()
{
poll_notify(POLLIN);
}
ssize_t
ADIS16448_gyro::read(struct file *filp, char *buffer, size_t buflen)
{
return _parent->gyro_read(filp, buffer, buflen);
}
int
ADIS16448_gyro::ioctl(struct file *filp, int cmd, unsigned long arg)
{
switch (cmd) {
case DEVIOCGDEVICEID:
return (int)CDev::ioctl(filp, cmd, arg);
break;
default:
return _parent->gyro_ioctl(filp, cmd, arg);
}
}
ADIS16448_mag::ADIS16448_mag(ADIS16448 *parent, const char *path) :
CDev("ADIS16448_mag", path),
_parent(parent),
_mag_topic(nullptr),
_mag_orb_class_instance(-1),
_mag_class_instance(-1)
{
}
ADIS16448_mag::~ADIS16448_mag()
{
if (_mag_class_instance != -1) {
unregister_class_devname(MAG_BASE_DEVICE_PATH, _mag_class_instance);
}
}
int
ADIS16448_mag::init()
{
int ret;
// do base class init
ret = CDev::init();
/* if probe/setup failed, bail now */
if (ret != OK) {
DEVICE_DEBUG("mag init failed");
return ret;
}
_mag_class_instance = register_class_devname(MAG_BASE_DEVICE_PATH);
return ret;
}
void
ADIS16448_mag::parent_poll_notify()
{
poll_notify(POLLIN);
}
ssize_t
ADIS16448_mag::read(struct file *filp, char *buffer, size_t buflen)
{
return _parent->mag_read(filp, buffer, buflen);
}
int
ADIS16448_mag::ioctl(struct file *filp, int cmd, unsigned long arg)
{
switch (cmd) {
case DEVIOCGDEVICEID:
return (int)CDev::ioctl(filp, cmd, arg);
break;
default:
return _parent->mag_ioctl(filp, cmd, arg);
}
}
/**
* Local functions in support of the shell command.
*/
namespace adis16448
{
ADIS16448 *g_dev;
void start(enum Rotation rotation);
void test();
void reset();
void info();
void info_cal();
void usage();
/**
* Start the driver.
*/
void
start(enum Rotation rotation)
{
int fd;
if (g_dev != nullptr)
/* if already started, the still command succeeded */
{
errx(0, "already started");
}
/* create the driver */
#if defined(PX4_SPI_BUS_EXT)
g_dev = new ADIS16448(PX4_SPI_BUS_EXT, ADIS16448_DEVICE_PATH_ACCEL, ADIS16448_DEVICE_PATH_GYRO,
ADIS16448_DEVICE_PATH_MAG, PX4_SPIDEV_EXT_MPU, rotation);
#else
PX4_ERR("External SPI not available");
exit(0);
#endif
if (g_dev == nullptr) {
goto fail;
}
if (OK != (g_dev)->init()) {
goto fail;
}
/* set the poll rate to default, starts automatic data collection */
fd = open(ADIS16448_DEVICE_PATH_ACCEL, O_RDONLY);
if (fd < 0) {
goto fail;
}
if (ioctl(fd, SENSORIOCSPOLLRATE, SENSOR_POLLRATE_DEFAULT) < 0) {
goto fail;
}
close(fd);
exit(0);
fail:
if (g_dev != nullptr) {
delete g_dev;
g_dev = nullptr;
}
errx(1, "driver start failed");
}
/**
* Perform some basic functional tests on the driver;
* make sure we can collect data from the sensor in polled
* and automatic modes.
*/
void
test()
{
accel_report a_report;
gyro_report g_report;
mag_report m_report;
ssize_t sz;
/* get the driver */
int fd = open(ADIS16448_DEVICE_PATH_ACCEL, O_RDONLY);
if (fd < 0) {
err(1, "%s open failed", ADIS16448_DEVICE_PATH_ACCEL);
}
/* get the mag driver */
int fd_mag = open(ADIS16448_DEVICE_PATH_MAG, O_RDONLY);
if (fd_mag < 0) {
err(1, "%s open failed", ADIS16448_DEVICE_PATH_MAG);
}
/* get the gyro driver */
int fd_gyro = open(ADIS16448_DEVICE_PATH_GYRO, O_RDONLY);
if (fd_gyro < 0) {
err(1, "%s open failed", ADIS16448_DEVICE_PATH_GYRO);
}
/* do a simple demand read */
sz = read(fd, &a_report, sizeof(a_report));
if (sz != sizeof(a_report)) {
warnx("ret: %d, expected: %d", sz, sizeof(a_report));
err(1, "immediate acc read failed");
}
print_message(a_report);
/* do a simple demand read */
sz = read(fd_gyro, &g_report, sizeof(g_report));
if (sz != sizeof(g_report)) {
warnx("ret: %d, expected: %d", sz, sizeof(g_report));
err(1, "immediate gyro read failed");
}
print_message(g_report);
/* do a simple mag demand read */
sz = read(fd_mag, &m_report, sizeof(m_report));
if (sz != sizeof(m_report)) {
warnx("ret: %d, expected: %d", sz, sizeof(m_report));
err(1, "immediate mag read failed");
}
print_message(m_report);
/* XXX add poll-rate tests here too */
close(fd_mag);
close(fd_gyro);
close(fd);
reset();
errx(0, "PASS");
}
/**
* Reset the driver.
*/
void
reset()
{
int fd = open(ADIS16448_DEVICE_PATH_ACCEL, O_RDONLY);
if (fd < 0) {
err(1, "open failed");
}
if (ioctl(fd, SENSORIOCRESET, 0) < 0) {
err(1, "driver reset failed");
}
if (ioctl(fd, SENSORIOCSPOLLRATE, SENSOR_POLLRATE_DEFAULT) < 0) {
err(1, "driver poll restart failed");
}
close(fd);
exit(0);
}
/**
* Print a little info about the driver.
*/
void
info()
{
if (g_dev == nullptr) {
errx(1, "driver not running");
}
printf("state @ %p\n", g_dev);
g_dev->print_info();
exit(0);
}
/**
* Print a sensor calibration info.
*/
void
info_cal()
{
if (g_dev == nullptr) {
errx(1, "driver not running");
}
g_dev->print_calibration_data();
exit(0);
}
void
usage()
{
warnx("missing command: try 'start', 'test', 'info', 'info_cal', 'reset',\n");
warnx("options:");
warnx(" -R rotation");
}
}
// namespace
int
adis16448_main(int argc, char *argv[])
{
enum Rotation rotation = ROTATION_NONE;
int ch;
/* start options */
while ((ch = getopt(argc, argv, "R:")) != EOF) {
switch (ch) {
case 'R':
rotation = (enum Rotation)atoi(optarg);
break;
default:
adis16448::usage();
exit(0);
}
}
const char *verb = argv[optind];
/*
* Start/load the driver.
*/
if (!strcmp(verb, "start")) {
adis16448::start(rotation);
}
/*
* Test the driver/device.
*/
if (!strcmp(verb, "test")) {
adis16448::test();
}
/*
* Reset the driver.
*/
if (!strcmp(verb, "reset")) {
adis16448::reset();
}
/*
* Print driver information.
*/
if (!strcmp(verb, "info")) {
adis16448::info();
}
/*
* Print sensor calibration information.
*/
if (!strcmp(verb, "info_cal")) {
adis16448::info_cal();
}
adis16448::usage();
exit(1);
}
Reference in New Issue View Git Blame Copy Permalink