From e189733bb97db12745446bf6afead84e09d8bf3f Mon Sep 17 00:00:00 2001 From: Daniel Agar Date: Fri, 27 Dec 2019 17:29:04 -0500 Subject: [PATCH] l3gd20: split into separate header, implementation, and main --- src/drivers/imu/l3gd20/CMakeLists.txt | 9 +- src/drivers/imu/l3gd20/L3GD20.cpp | 461 ++++++++++++ src/drivers/imu/l3gd20/L3GD20.hpp | 290 ++++++++ src/drivers/imu/l3gd20/l3gd20.cpp | 934 ------------------------- src/drivers/imu/l3gd20/l3gd20_main.cpp | 193 +++++ 5 files changed, 950 insertions(+), 937 deletions(-) create mode 100644 src/drivers/imu/l3gd20/L3GD20.cpp create mode 100644 src/drivers/imu/l3gd20/L3GD20.hpp delete mode 100644 src/drivers/imu/l3gd20/l3gd20.cpp create mode 100644 src/drivers/imu/l3gd20/l3gd20_main.cpp diff --git a/src/drivers/imu/l3gd20/CMakeLists.txt b/src/drivers/imu/l3gd20/CMakeLists.txt index 6e090a9308..fd1e672436 100644 --- a/src/drivers/imu/l3gd20/CMakeLists.txt +++ b/src/drivers/imu/l3gd20/CMakeLists.txt @@ -1,6 +1,6 @@ ############################################################################ # -# Copyright (c) 2015 PX4 Development Team. All rights reserved. +# Copyright (c) 2015-2019 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 @@ -31,12 +31,15 @@ # ############################################################################ px4_add_module( - MODULE drivers__l3gd20 + MODULE drivers__imu__l3gd20 MAIN l3gd20 COMPILE_FLAGS -Wno-cast-align # TODO: fix and enable SRCS - l3gd20.cpp + L3GD20.hpp + L3GD20.cpp + l3gd20_main.cpp DEPENDS drivers_gyroscope + px4_work_queue ) diff --git a/src/drivers/imu/l3gd20/L3GD20.cpp b/src/drivers/imu/l3gd20/L3GD20.cpp new file mode 100644 index 0000000000..0621484872 --- /dev/null +++ b/src/drivers/imu/l3gd20/L3GD20.cpp @@ -0,0 +1,461 @@ +/**************************************************************************** + * + * Copyright (c) 2012-2019 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. + * + ****************************************************************************/ + +#include "L3GD20.hpp" + +constexpr uint8_t L3GD20::_checked_registers[]; + +L3GD20::L3GD20(int bus, uint32_t device, enum Rotation rotation) : + SPI("L3GD20", nullptr, bus, device, SPIDEV_MODE3, 11 * 1000 * 1000), + ScheduledWorkItem(MODULE_NAME, px4::device_bus_to_wq(this->get_device_id())), + _px4_gyro(get_device_id(), ORB_PRIO_DEFAULT, rotation), + _sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")), + _errors(perf_alloc(PC_COUNT, MODULE_NAME": err")), + _bad_registers(perf_alloc(PC_COUNT, MODULE_NAME": bad_reg")), + _duplicates(perf_alloc(PC_COUNT, MODULE_NAME": dupe")) +{ + _px4_gyro.set_device_type(DRV_GYR_DEVTYPE_L3GD20); +} + +L3GD20::~L3GD20() +{ + /* make sure we are truly inactive */ + stop(); + + /* delete the perf counter */ + perf_free(_sample_perf); + perf_free(_errors); + perf_free(_bad_registers); + perf_free(_duplicates); +} + +int +L3GD20::init() +{ + /* do SPI init (and probe) first */ + if (SPI::init() != OK) { + return PX4_ERROR; + } + + reset(); + + start(); + + return PX4_OK; +} + +int +L3GD20::probe() +{ + /* read dummy value to void to clear SPI statemachine on sensor */ + read_reg(ADDR_WHO_AM_I); + + bool success = false; + uint8_t v = 0; + + /* verify that the device is attached and functioning, accept + * L3GD20, L3GD20H and L3G4200D */ + if ((v = read_reg(ADDR_WHO_AM_I)) == WHO_I_AM) { + _orientation = SENSOR_BOARD_ROTATION_DEFAULT; + success = true; + + } else if ((v = read_reg(ADDR_WHO_AM_I)) == WHO_I_AM_H) { + _orientation = SENSOR_BOARD_ROTATION_180_DEG; + success = true; + + } else if ((v = read_reg(ADDR_WHO_AM_I)) == WHO_I_AM_L3G4200D) { + /* Detect the L3G4200D used on AeroCore */ + _is_l3g4200d = true; + _orientation = SENSOR_BOARD_ROTATION_DEFAULT; + success = true; + } + + if (success) { + _checked_values[0] = v; + return OK; + } + + return -EIO; +} + +uint8_t +L3GD20::read_reg(unsigned reg) +{ + uint8_t cmd[2] {}; + + cmd[0] = reg | DIR_READ; + cmd[1] = 0; + + transfer(cmd, cmd, sizeof(cmd)); + + return cmd[1]; +} + +void +L3GD20::write_reg(unsigned reg, uint8_t value) +{ + uint8_t cmd[2] {}; + + cmd[0] = reg | DIR_WRITE; + cmd[1] = value; + + transfer(cmd, nullptr, sizeof(cmd)); +} + +void +L3GD20::write_checked_reg(unsigned reg, uint8_t value) +{ + write_reg(reg, value); + + for (uint8_t i = 0; i < L3GD20_NUM_CHECKED_REGISTERS; i++) { + if (reg == _checked_registers[i]) { + _checked_values[i] = value; + } + } +} + +void +L3GD20::modify_reg(unsigned reg, uint8_t clearbits, uint8_t setbits) +{ + uint8_t val = read_reg(reg); + val &= ~clearbits; + val |= setbits; + write_checked_reg(reg, val); +} + +int +L3GD20::set_range(unsigned max_dps) +{ + uint8_t bits = REG4_BDU; + float new_range_scale_dps_digit; + + if (max_dps == 0) { + max_dps = 2000; + } + + if (max_dps <= 250) { + //new_range = 250; + bits |= RANGE_250DPS; + new_range_scale_dps_digit = 8.75e-3f; + + } else if (max_dps <= 500) { + //new_range = 500; + bits |= RANGE_500DPS; + new_range_scale_dps_digit = 17.5e-3f; + + } else if (max_dps <= 2000) { + //new_range = 2000; + bits |= RANGE_2000DPS; + new_range_scale_dps_digit = 70e-3f; + + } else { + return -EINVAL; + } + + _px4_gyro.set_scale(new_range_scale_dps_digit / 180.0f * M_PI_F); + + write_checked_reg(ADDR_CTRL_REG4, bits); + + return OK; +} + +int +L3GD20::set_samplerate(unsigned frequency) +{ + uint8_t bits = REG1_POWER_NORMAL | REG1_Z_ENABLE | REG1_Y_ENABLE | REG1_X_ENABLE; + + if (frequency == 0) { + frequency = _is_l3g4200d ? 800 : 760; + } + + /* + * Use limits good for H or non-H models. Rates are slightly different + * for L3G4200D part but register settings are the same. + */ + if (frequency <= 100) { + bits |= RATE_95HZ_LP_25HZ; + + } else if (frequency <= 200) { + bits |= RATE_190HZ_LP_50HZ; + + } else if (frequency <= 400) { + bits |= RATE_380HZ_LP_50HZ; + + } else if (frequency <= 800) { + bits |= RATE_760HZ_LP_50HZ; + + } else { + return -EINVAL; + } + + write_checked_reg(ADDR_CTRL_REG1, bits); + + return OK; +} + +void +L3GD20::start() +{ + /* make sure we are stopped first */ + stop(); + + /* start polling at the specified rate */ + uint64_t interval = 1000000 / L3GD20_DEFAULT_RATE; + ScheduleOnInterval(interval - L3GD20_TIMER_REDUCTION, 10000); +} + +void +L3GD20::stop() +{ + ScheduleClear(); +} + +void +L3GD20::disable_i2c() +{ + uint8_t retries = 10; + + while (retries--) { + // add retries + uint8_t a = read_reg(0x05); + write_reg(0x05, (0x20 | a)); + + if (read_reg(0x05) == (a | 0x20)) { + // this sets the I2C_DIS bit on the + // L3GD20H. The l3gd20 datasheet doesn't + // mention this register, but it does seem to + // accept it. + write_checked_reg(ADDR_LOW_ODR, 0x08); + return; + } + } + + DEVICE_DEBUG("FAILED TO DISABLE I2C"); +} + +void +L3GD20::reset() +{ + // ensure the chip doesn't interpret any other bus traffic as I2C + disable_i2c(); + + /* set default configuration */ + write_checked_reg(ADDR_CTRL_REG1, REG1_POWER_NORMAL | REG1_Z_ENABLE | REG1_Y_ENABLE | REG1_X_ENABLE); + write_checked_reg(ADDR_CTRL_REG2, 0); /* disable high-pass filters */ + write_checked_reg(ADDR_CTRL_REG3, 0x08); /* DRDY enable */ + write_checked_reg(ADDR_CTRL_REG4, REG4_BDU); + write_checked_reg(ADDR_CTRL_REG5, 0); + write_checked_reg(ADDR_CTRL_REG5, REG5_FIFO_ENABLE); /* disable wake-on-interrupt */ + + /* disable FIFO. This makes things simpler and ensures we + * aren't getting stale data. It means we must run the hrt + * callback fast enough to not miss data. */ + write_checked_reg(ADDR_FIFO_CTRL_REG, FIFO_CTRL_BYPASS_MODE); + + set_samplerate(0); // 760Hz or 800Hz + set_range(L3GD20_DEFAULT_RANGE_DPS); + + _read = 0; +} + +void +L3GD20::Run() +{ + /* make another measurement */ + measure(); +} + +void +L3GD20::check_registers() +{ + uint8_t v; + + if ((v = read_reg(_checked_registers[_checked_next])) != _checked_values[_checked_next]) { + /* + if we get the wrong value then we know the SPI bus + or sensor is very sick. We set _register_wait to 20 + and wait until we have seen 20 good values in a row + before we consider the sensor to be OK again. + */ + perf_count(_bad_registers); + + /* + try to fix the bad register value. We only try to + fix one per loop to prevent a bad sensor hogging the + bus. We skip zero as that is the WHO_AM_I, which + is not writeable + */ + if (_checked_next != 0) { + write_reg(_checked_registers[_checked_next], _checked_values[_checked_next]); + } + + _register_wait = 20; + } + + _checked_next = (_checked_next + 1) % L3GD20_NUM_CHECKED_REGISTERS; +} + +void +L3GD20::measure() +{ + /* status register and data as read back from the device */ +#pragma pack(push, 1) + struct { + uint8_t cmd; + int8_t temp; + uint8_t status; + int16_t x; + int16_t y; + int16_t z; + } raw_report{}; +#pragma pack(pop) + + /* start the performance counter */ + perf_begin(_sample_perf); + + check_registers(); + + /* fetch data from the sensor */ + const hrt_abstime timestamp_sample = hrt_absolute_time(); + raw_report.cmd = ADDR_OUT_TEMP | DIR_READ | ADDR_INCREMENT; + transfer((uint8_t *)&raw_report, (uint8_t *)&raw_report, sizeof(raw_report)); + + if (!(raw_report.status & STATUS_ZYXDA)) { + perf_end(_sample_perf); + perf_count(_duplicates); + return; + } + + /* + * 1) Scale raw value to SI units using scaling from datasheet. + * 2) Subtract static offset (in SI units) + * 3) Scale the statically calibrated values with a linear + * dynamically obtained factor + * + * Note: the static sensor offset is the number the sensor outputs + * at a nominally 'zero' input. Therefore the offset has to + * be subtracted. + * + * Example: A gyro outputs a value of 74 at zero angular rate + * the offset is 74 from the origin and subtracting + * 74 from all measurements centers them around zero. + */ + _px4_gyro.set_error_count(perf_event_count(_bad_registers)); + + _px4_gyro.set_temperature(L3GD20_TEMP_OFFSET_CELSIUS - raw_report.temp); + + switch (_orientation) { + case SENSOR_BOARD_ROTATION_090_DEG: + /* swap x and y */ + _px4_gyro.update(timestamp_sample, raw_report.y, raw_report.x, raw_report.z); + break; + + case SENSOR_BOARD_ROTATION_180_DEG: { + /* swap x and y and negate both */ + int16_t x = ((raw_report.x == -32768) ? 32767 : -raw_report.x); + int16_t y = ((raw_report.y == -32768) ? 32767 : -raw_report.y); + _px4_gyro.update(timestamp_sample, x, y, raw_report.z); + } + + break; + + case SENSOR_BOARD_ROTATION_270_DEG: { + /* swap x and y and negate y */ + int16_t x = raw_report.y; + int16_t y = ((raw_report.x == -32768) ? 32767 : -raw_report.x); + _px4_gyro.update(timestamp_sample, x, y, raw_report.z); + } + break; + + case SENSOR_BOARD_ROTATION_000_DEG: + + // FALLTHROUGH + default: + // keep axes in place + _px4_gyro.update(timestamp_sample, raw_report.x, raw_report.y, raw_report.z); + } + + _read++; + + /* stop the perf counter */ + perf_end(_sample_perf); +} + +void +L3GD20::print_info() +{ + printf("gyro reads: %u\n", _read); + perf_print_counter(_sample_perf); + perf_print_counter(_errors); + perf_print_counter(_bad_registers); + perf_print_counter(_duplicates); + + ::printf("checked_next: %u\n", _checked_next); + + for (uint8_t i = 0; i < L3GD20_NUM_CHECKED_REGISTERS; i++) { + uint8_t v = read_reg(_checked_registers[i]); + + if (v != _checked_values[i]) { + ::printf("reg %02x:%02x should be %02x\n", + (unsigned)_checked_registers[i], + (unsigned)v, + (unsigned)_checked_values[i]); + } + } + + _px4_gyro.print_status(); +} + +void +L3GD20::print_registers() +{ + printf("L3GD20 registers\n"); + + for (uint8_t reg = 0; reg <= 0x40; reg++) { + uint8_t v = read_reg(reg); + printf("%02x:%02x ", (unsigned)reg, (unsigned)v); + + if ((reg + 1) % 16 == 0) { + printf("\n"); + } + } + + printf("\n"); +} + +void +L3GD20::test_error() +{ + // trigger a deliberate error + write_reg(ADDR_CTRL_REG3, 0); +} diff --git a/src/drivers/imu/l3gd20/L3GD20.hpp b/src/drivers/imu/l3gd20/L3GD20.hpp new file mode 100644 index 0000000000..e3411e0e7f --- /dev/null +++ b/src/drivers/imu/l3gd20/L3GD20.hpp @@ -0,0 +1,290 @@ +/**************************************************************************** + * + * Copyright (c) 2012-2019 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 l3gd20.cpp + * Driver for the ST L3GD20 MEMS and L3GD20H mems gyros connected via SPI. + * + * Note: With the exception of the self-test feature, the ST L3G4200D is + * also supported by this driver. + */ + +#include +#include +#include +#include +#include +#include + +/* Orientation on board */ +#define SENSOR_BOARD_ROTATION_000_DEG 0 +#define SENSOR_BOARD_ROTATION_090_DEG 1 +#define SENSOR_BOARD_ROTATION_180_DEG 2 +#define SENSOR_BOARD_ROTATION_270_DEG 3 + +/* SPI protocol address bits */ +#define DIR_READ (1<<7) +#define DIR_WRITE (0<<7) +#define ADDR_INCREMENT (1<<6) + +/* register addresses */ +#define ADDR_WHO_AM_I 0x0F +#define WHO_I_AM_H 0xD7 +#define WHO_I_AM 0xD4 +#define WHO_I_AM_L3G4200D 0xD3 /* for L3G4200D */ + +#define ADDR_CTRL_REG1 0x20 +#define REG1_RATE_LP_MASK 0xF0 /* Mask to guard partial register update */ + +/* keep lowpass low to avoid noise issues */ +#define RATE_95HZ_LP_25HZ ((0<<7) | (0<<6) | (0<<5) | (1<<4)) +#define RATE_190HZ_LP_25HZ ((0<<7) | (1<<6) | (0<<5) | (1<<4)) +#define RATE_190HZ_LP_50HZ ((0<<7) | (1<<6) | (1<<5) | (0<<4)) +#define RATE_190HZ_LP_70HZ ((0<<7) | (1<<6) | (1<<5) | (1<<4)) +#define RATE_380HZ_LP_20HZ ((1<<7) | (0<<6) | (1<<5) | (0<<4)) +#define RATE_380HZ_LP_25HZ ((1<<7) | (0<<6) | (0<<5) | (1<<4)) +#define RATE_380HZ_LP_50HZ ((1<<7) | (0<<6) | (1<<5) | (0<<4)) +#define RATE_380HZ_LP_100HZ ((1<<7) | (0<<6) | (1<<5) | (1<<4)) +#define RATE_760HZ_LP_30HZ ((1<<7) | (1<<6) | (0<<5) | (0<<4)) +#define RATE_760HZ_LP_35HZ ((1<<7) | (1<<6) | (0<<5) | (1<<4)) +#define RATE_760HZ_LP_50HZ ((1<<7) | (1<<6) | (1<<5) | (0<<4)) +#define RATE_760HZ_LP_100HZ ((1<<7) | (1<<6) | (1<<5) | (1<<4)) + +#define ADDR_CTRL_REG2 0x21 +#define ADDR_CTRL_REG3 0x22 +#define ADDR_CTRL_REG4 0x23 +#define REG4_RANGE_MASK 0x30 /* Mask to guard partial register update */ +#define RANGE_250DPS (0<<4) +#define RANGE_500DPS (1<<4) +#define RANGE_2000DPS (3<<4) + +#define ADDR_CTRL_REG5 0x24 +#define ADDR_REFERENCE 0x25 +#define ADDR_OUT_TEMP 0x26 +#define ADDR_STATUS_REG 0x27 +#define ADDR_OUT_X_L 0x28 +#define ADDR_OUT_X_H 0x29 +#define ADDR_OUT_Y_L 0x2A +#define ADDR_OUT_Y_H 0x2B +#define ADDR_OUT_Z_L 0x2C +#define ADDR_OUT_Z_H 0x2D +#define ADDR_FIFO_CTRL_REG 0x2E +#define ADDR_FIFO_SRC_REG 0x2F +#define ADDR_INT1_CFG 0x30 +#define ADDR_INT1_SRC 0x31 +#define ADDR_INT1_TSH_XH 0x32 +#define ADDR_INT1_TSH_XL 0x33 +#define ADDR_INT1_TSH_YH 0x34 +#define ADDR_INT1_TSH_YL 0x35 +#define ADDR_INT1_TSH_ZH 0x36 +#define ADDR_INT1_TSH_ZL 0x37 +#define ADDR_INT1_DURATION 0x38 +#define ADDR_LOW_ODR 0x39 + + +/* Internal configuration values */ +#define REG1_POWER_NORMAL (1<<3) +#define REG1_Z_ENABLE (1<<2) +#define REG1_Y_ENABLE (1<<1) +#define REG1_X_ENABLE (1<<0) + +#define REG4_BDU (1<<7) +#define REG4_BLE (1<<6) +//#define REG4_SPI_3WIRE (1<<0) + +#define REG5_FIFO_ENABLE (1<<6) +#define REG5_REBOOT_MEMORY (1<<7) + +#define STATUS_ZYXOR (1<<7) +#define STATUS_ZOR (1<<6) +#define STATUS_YOR (1<<5) +#define STATUS_XOR (1<<4) +#define STATUS_ZYXDA (1<<3) +#define STATUS_ZDA (1<<2) +#define STATUS_YDA (1<<1) +#define STATUS_XDA (1<<0) + +#define FIFO_CTRL_BYPASS_MODE (0<<5) +#define FIFO_CTRL_FIFO_MODE (1<<5) +#define FIFO_CTRL_STREAM_MODE (1<<6) +#define FIFO_CTRL_STREAM_TO_FIFO_MODE (3<<5) +#define FIFO_CTRL_BYPASS_TO_STREAM_MODE (1<<7) + +#define L3GD20_DEFAULT_RATE 760 +#define L3GD20_DEFAULT_RANGE_DPS 2000 +#define L3GD20_TEMP_OFFSET_CELSIUS 40 + +#define L3GD20_MAX_OFFSET 0.45f /**< max offset: 25 degrees/s */ + +#ifndef SENSOR_BOARD_ROTATION_DEFAULT +#define SENSOR_BOARD_ROTATION_DEFAULT SENSOR_BOARD_ROTATION_270_DEG +#endif + +/* + we set the timer interrupt to run a bit faster than the desired + sample rate and then throw away duplicates using the data ready bit. + This time reduction is enough to cope with worst case timing jitter + due to other timers + */ +#define L3GD20_TIMER_REDUCTION 600 + +class L3GD20 : public device::SPI, public px4::ScheduledWorkItem +{ +public: + L3GD20(int bus, uint32_t device, enum Rotation rotation); + virtual ~L3GD20(); + + virtual int init(); + + /** + * Diagnostics - print some basic information about the driver. + */ + void print_info(); + + // print register dump + void print_registers(); + + // trigger an error + void test_error(); + +protected: + virtual int probe(); + +private: + + PX4Gyroscope _px4_gyro; + + unsigned _orientation{SENSOR_BOARD_ROTATION_DEFAULT}; + + unsigned _read{0}; + + perf_counter_t _sample_perf; + perf_counter_t _errors; + perf_counter_t _bad_registers; + perf_counter_t _duplicates; + + uint8_t _register_wait{0}; + + /* true if an L3G4200D is detected */ + bool _is_l3g4200d{false}; + + // this is used to support runtime checking of key + // configuration registers to detect SPI bus errors and sensor + // reset + static constexpr int L3GD20_NUM_CHECKED_REGISTERS{8}; + static constexpr uint8_t _checked_registers[] = { + ADDR_WHO_AM_I, + ADDR_CTRL_REG1, + ADDR_CTRL_REG2, + ADDR_CTRL_REG3, + ADDR_CTRL_REG4, + ADDR_CTRL_REG5, + ADDR_FIFO_CTRL_REG, + ADDR_LOW_ODR + }; + + uint8_t _checked_values[L3GD20_NUM_CHECKED_REGISTERS] {}; + uint8_t _checked_next{0}; + + void start(); + void stop(); + void reset(); + void disable_i2c(); + void Run() override; + + /** + * check key registers for correct values + */ + void check_registers(); + + /** + * Fetch measurements from the sensor and update the report ring. + */ + void measure(); + + /** + * Read a register from the L3GD20 + * + * @param The register to read. + * @return The value that was read. + */ + uint8_t read_reg(unsigned reg); + + /** + * Write a register in the L3GD20 + * + * @param reg The register to write. + * @param value The new value to write. + */ + void write_reg(unsigned reg, uint8_t value); + + /** + * Modify a register in the L3GD20 + * + * 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_reg(unsigned reg, uint8_t clearbits, uint8_t setbits); + + /** + * Write a register in the L3GD20, updating _checked_values + * + * @param reg The register to write. + * @param value The new value to write. + */ + void write_checked_reg(unsigned reg, uint8_t value); + + /** + * Set the L3GD20 measurement range. + * + * @param max_dps The measurement range is set to permit reading at least + * this rate in degrees per second. + * Zero selects the maximum supported range. + * @return OK if the value can be supported, -ERANGE otherwise. + */ + int set_range(unsigned max_dps); + + /** + * Set the L3GD20 internal sampling frequency. + * + * @param frequency The internal sampling frequency is set to not less than + * this value. + * Zero selects the maximum rate supported. + * @return OK if the value can be supported. + */ + int set_samplerate(unsigned frequency); + +}; diff --git a/src/drivers/imu/l3gd20/l3gd20.cpp b/src/drivers/imu/l3gd20/l3gd20.cpp deleted file mode 100644 index 5e03ea8d72..0000000000 --- a/src/drivers/imu/l3gd20/l3gd20.cpp +++ /dev/null @@ -1,934 +0,0 @@ -/**************************************************************************** - * - * Copyright (c) 2012-2019 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 l3gd20.cpp - * Driver for the ST L3GD20 MEMS and L3GD20H mems gyros connected via SPI. - * - * Note: With the exception of the self-test feature, the ST L3G4200D is - * also supported by this driver. - */ - -#include -#include -#include -#include -#include -#include - -#define L3GD20_DEVICE_PATH "/dev/l3gd20" - -/* Orientation on board */ -#define SENSOR_BOARD_ROTATION_000_DEG 0 -#define SENSOR_BOARD_ROTATION_090_DEG 1 -#define SENSOR_BOARD_ROTATION_180_DEG 2 -#define SENSOR_BOARD_ROTATION_270_DEG 3 - -/* SPI protocol address bits */ -#define DIR_READ (1<<7) -#define DIR_WRITE (0<<7) -#define ADDR_INCREMENT (1<<6) - -/* register addresses */ -#define ADDR_WHO_AM_I 0x0F -#define WHO_I_AM_H 0xD7 -#define WHO_I_AM 0xD4 -#define WHO_I_AM_L3G4200D 0xD3 /* for L3G4200D */ - -#define ADDR_CTRL_REG1 0x20 -#define REG1_RATE_LP_MASK 0xF0 /* Mask to guard partial register update */ - -/* keep lowpass low to avoid noise issues */ -#define RATE_95HZ_LP_25HZ ((0<<7) | (0<<6) | (0<<5) | (1<<4)) -#define RATE_190HZ_LP_25HZ ((0<<7) | (1<<6) | (0<<5) | (1<<4)) -#define RATE_190HZ_LP_50HZ ((0<<7) | (1<<6) | (1<<5) | (0<<4)) -#define RATE_190HZ_LP_70HZ ((0<<7) | (1<<6) | (1<<5) | (1<<4)) -#define RATE_380HZ_LP_20HZ ((1<<7) | (0<<6) | (1<<5) | (0<<4)) -#define RATE_380HZ_LP_25HZ ((1<<7) | (0<<6) | (0<<5) | (1<<4)) -#define RATE_380HZ_LP_50HZ ((1<<7) | (0<<6) | (1<<5) | (0<<4)) -#define RATE_380HZ_LP_100HZ ((1<<7) | (0<<6) | (1<<5) | (1<<4)) -#define RATE_760HZ_LP_30HZ ((1<<7) | (1<<6) | (0<<5) | (0<<4)) -#define RATE_760HZ_LP_35HZ ((1<<7) | (1<<6) | (0<<5) | (1<<4)) -#define RATE_760HZ_LP_50HZ ((1<<7) | (1<<6) | (1<<5) | (0<<4)) -#define RATE_760HZ_LP_100HZ ((1<<7) | (1<<6) | (1<<5) | (1<<4)) - -#define ADDR_CTRL_REG2 0x21 -#define ADDR_CTRL_REG3 0x22 -#define ADDR_CTRL_REG4 0x23 -#define REG4_RANGE_MASK 0x30 /* Mask to guard partial register update */ -#define RANGE_250DPS (0<<4) -#define RANGE_500DPS (1<<4) -#define RANGE_2000DPS (3<<4) - -#define ADDR_CTRL_REG5 0x24 -#define ADDR_REFERENCE 0x25 -#define ADDR_OUT_TEMP 0x26 -#define ADDR_STATUS_REG 0x27 -#define ADDR_OUT_X_L 0x28 -#define ADDR_OUT_X_H 0x29 -#define ADDR_OUT_Y_L 0x2A -#define ADDR_OUT_Y_H 0x2B -#define ADDR_OUT_Z_L 0x2C -#define ADDR_OUT_Z_H 0x2D -#define ADDR_FIFO_CTRL_REG 0x2E -#define ADDR_FIFO_SRC_REG 0x2F -#define ADDR_INT1_CFG 0x30 -#define ADDR_INT1_SRC 0x31 -#define ADDR_INT1_TSH_XH 0x32 -#define ADDR_INT1_TSH_XL 0x33 -#define ADDR_INT1_TSH_YH 0x34 -#define ADDR_INT1_TSH_YL 0x35 -#define ADDR_INT1_TSH_ZH 0x36 -#define ADDR_INT1_TSH_ZL 0x37 -#define ADDR_INT1_DURATION 0x38 -#define ADDR_LOW_ODR 0x39 - - -/* Internal configuration values */ -#define REG1_POWER_NORMAL (1<<3) -#define REG1_Z_ENABLE (1<<2) -#define REG1_Y_ENABLE (1<<1) -#define REG1_X_ENABLE (1<<0) - -#define REG4_BDU (1<<7) -#define REG4_BLE (1<<6) -//#define REG4_SPI_3WIRE (1<<0) - -#define REG5_FIFO_ENABLE (1<<6) -#define REG5_REBOOT_MEMORY (1<<7) - -#define STATUS_ZYXOR (1<<7) -#define STATUS_ZOR (1<<6) -#define STATUS_YOR (1<<5) -#define STATUS_XOR (1<<4) -#define STATUS_ZYXDA (1<<3) -#define STATUS_ZDA (1<<2) -#define STATUS_YDA (1<<1) -#define STATUS_XDA (1<<0) - -#define FIFO_CTRL_BYPASS_MODE (0<<5) -#define FIFO_CTRL_FIFO_MODE (1<<5) -#define FIFO_CTRL_STREAM_MODE (1<<6) -#define FIFO_CTRL_STREAM_TO_FIFO_MODE (3<<5) -#define FIFO_CTRL_BYPASS_TO_STREAM_MODE (1<<7) - -#define L3GD20_DEFAULT_RATE 760 -#define L3G4200D_DEFAULT_RATE 800 -#define L3GD20_MAX_OUTPUT_RATE 280 -#define L3GD20_DEFAULT_RANGE_DPS 2000 -#define L3GD20_DEFAULT_FILTER_FREQ 30 -#define L3GD20_TEMP_OFFSET_CELSIUS 40 - -#define L3GD20_MAX_OFFSET 0.45f /**< max offset: 25 degrees/s */ - -#ifndef SENSOR_BOARD_ROTATION_DEFAULT -#define SENSOR_BOARD_ROTATION_DEFAULT SENSOR_BOARD_ROTATION_270_DEG -#endif - -/* - we set the timer interrupt to run a bit faster than the desired - sample rate and then throw away duplicates using the data ready bit. - This time reduction is enough to cope with worst case timing jitter - due to other timers - */ -#define L3GD20_TIMER_REDUCTION 600 - -extern "C" { __EXPORT int l3gd20_main(int argc, char *argv[]); } - -class L3GD20 : public device::SPI, public px4::ScheduledWorkItem -{ -public: - L3GD20(int bus, const char *path, uint32_t device, enum Rotation rotation); - virtual ~L3GD20(); - - virtual int init(); - - /** - * Diagnostics - print some basic information about the driver. - */ - void print_info(); - - // print register dump - void print_registers(); - - // trigger an error - void test_error(); - -protected: - virtual int probe(); - -private: - - PX4Gyroscope _px4_gyro; - - unsigned _current_rate{0}; - unsigned _orientation{SENSOR_BOARD_ROTATION_DEFAULT}; - - unsigned _read{0}; - - perf_counter_t _sample_perf; - perf_counter_t _errors; - perf_counter_t _bad_registers; - perf_counter_t _duplicates; - - uint8_t _register_wait{0}; - - /* true if an L3G4200D is detected */ - bool _is_l3g4200d{false}; - - enum Rotation _rotation; - - // this is used to support runtime checking of key - // configuration registers to detect SPI bus errors and sensor - // reset - static constexpr int L3GD20_NUM_CHECKED_REGISTERS{8}; - static constexpr uint8_t _checked_registers[] = { - ADDR_WHO_AM_I, - ADDR_CTRL_REG1, - ADDR_CTRL_REG2, - ADDR_CTRL_REG3, - ADDR_CTRL_REG4, - ADDR_CTRL_REG5, - ADDR_FIFO_CTRL_REG, - ADDR_LOW_ODR - }; - - uint8_t _checked_values[L3GD20_NUM_CHECKED_REGISTERS] {}; - uint8_t _checked_next{0}; - - /** - * Start automatic measurement. - */ - void start(); - - /** - * Stop automatic measurement. - */ - void stop(); - - /** - * Reset the driver - */ - void reset(); - - /** - * disable I2C on the chip - */ - void disable_i2c(); - - void Run() override; - - /** - * check key registers for correct values - */ - void check_registers(void); - - /** - * Fetch measurements from the sensor and update the report ring. - */ - void measure(); - - /** - * Read a register from the L3GD20 - * - * @param The register to read. - * @return The value that was read. - */ - uint8_t read_reg(unsigned reg); - - /** - * Write a register in the L3GD20 - * - * @param reg The register to write. - * @param value The new value to write. - */ - void write_reg(unsigned reg, uint8_t value); - - /** - * Modify a register in the L3GD20 - * - * 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_reg(unsigned reg, uint8_t clearbits, uint8_t setbits); - - /** - * Write a register in the L3GD20, updating _checked_values - * - * @param reg The register to write. - * @param value The new value to write. - */ - void write_checked_reg(unsigned reg, uint8_t value); - - /** - * Set the L3GD20 measurement range. - * - * @param max_dps The measurement range is set to permit reading at least - * this rate in degrees per second. - * Zero selects the maximum supported range. - * @return OK if the value can be supported, -ERANGE otherwise. - */ - int set_range(unsigned max_dps); - - /** - * Set the L3GD20 internal sampling frequency. - * - * @param frequency The internal sampling frequency is set to not less than - * this value. - * Zero selects the maximum rate supported. - * @return OK if the value can be supported. - */ - int set_samplerate(unsigned frequency); - - /* this class does not allow copying */ - L3GD20(const L3GD20 &); - L3GD20 operator=(const L3GD20 &); -}; - -constexpr uint8_t L3GD20::_checked_registers[]; - -L3GD20::L3GD20(int bus, const char *path, uint32_t device, enum Rotation rotation) : - SPI("L3GD20", path, bus, device, SPIDEV_MODE3, 11 * 1000 * 1000), - ScheduledWorkItem(MODULE_NAME, px4::device_bus_to_wq(this->get_device_id())), - _px4_gyro(get_device_id(), ORB_PRIO_DEFAULT, rotation), - _sample_perf(perf_alloc(PC_ELAPSED, "l3gd20_read")), - _errors(perf_alloc(PC_COUNT, "l3gd20_err")), - _bad_registers(perf_alloc(PC_COUNT, "l3gd20_bad_reg")), - _duplicates(perf_alloc(PC_COUNT, "l3gd20_dupe")), - _rotation(rotation) -{ - _px4_gyro.set_device_type(DRV_GYR_DEVTYPE_L3GD20); -} - -L3GD20::~L3GD20() -{ - /* make sure we are truly inactive */ - stop(); - - /* delete the perf counter */ - perf_free(_sample_perf); - perf_free(_errors); - perf_free(_bad_registers); - perf_free(_duplicates); -} - -int -L3GD20::init() -{ - /* do SPI init (and probe) first */ - if (SPI::init() != OK) { - return PX4_ERROR; - } - - reset(); - - start(); - - return PX4_OK; -} - -int -L3GD20::probe() -{ - /* read dummy value to void to clear SPI statemachine on sensor */ - (void)read_reg(ADDR_WHO_AM_I); - - bool success = false; - uint8_t v = 0; - - /* verify that the device is attached and functioning, accept - * L3GD20, L3GD20H and L3G4200D */ - if ((v = read_reg(ADDR_WHO_AM_I)) == WHO_I_AM) { - _orientation = SENSOR_BOARD_ROTATION_DEFAULT; - success = true; - - } else if ((v = read_reg(ADDR_WHO_AM_I)) == WHO_I_AM_H) { - _orientation = SENSOR_BOARD_ROTATION_180_DEG; - success = true; - - } else if ((v = read_reg(ADDR_WHO_AM_I)) == WHO_I_AM_L3G4200D) { - /* Detect the L3G4200D used on AeroCore */ - _is_l3g4200d = true; - _orientation = SENSOR_BOARD_ROTATION_DEFAULT; - success = true; - } - - if (success) { - _checked_values[0] = v; - return OK; - } - - return -EIO; -} - -uint8_t -L3GD20::read_reg(unsigned reg) -{ - uint8_t cmd[2] {}; - - cmd[0] = reg | DIR_READ; - cmd[1] = 0; - - transfer(cmd, cmd, sizeof(cmd)); - - return cmd[1]; -} - -void -L3GD20::write_reg(unsigned reg, uint8_t value) -{ - uint8_t cmd[2] {}; - - cmd[0] = reg | DIR_WRITE; - cmd[1] = value; - - transfer(cmd, nullptr, sizeof(cmd)); -} - -void -L3GD20::write_checked_reg(unsigned reg, uint8_t value) -{ - write_reg(reg, value); - - for (uint8_t i = 0; i < L3GD20_NUM_CHECKED_REGISTERS; i++) { - if (reg == _checked_registers[i]) { - _checked_values[i] = value; - } - } -} - - -void -L3GD20::modify_reg(unsigned reg, uint8_t clearbits, uint8_t setbits) -{ - uint8_t val = read_reg(reg); - val &= ~clearbits; - val |= setbits; - write_checked_reg(reg, val); -} - -int -L3GD20::set_range(unsigned max_dps) -{ - uint8_t bits = REG4_BDU; - float new_range_scale_dps_digit; - - if (max_dps == 0) { - max_dps = 2000; - } - - if (max_dps <= 250) { - //new_range = 250; - bits |= RANGE_250DPS; - new_range_scale_dps_digit = 8.75e-3f; - - } else if (max_dps <= 500) { - //new_range = 500; - bits |= RANGE_500DPS; - new_range_scale_dps_digit = 17.5e-3f; - - } else if (max_dps <= 2000) { - //new_range = 2000; - bits |= RANGE_2000DPS; - new_range_scale_dps_digit = 70e-3f; - - } else { - return -EINVAL; - } - - _px4_gyro.set_scale(new_range_scale_dps_digit / 180.0f * M_PI_F); - - write_checked_reg(ADDR_CTRL_REG4, bits); - - return OK; -} - -int -L3GD20::set_samplerate(unsigned frequency) -{ - uint8_t bits = REG1_POWER_NORMAL | REG1_Z_ENABLE | REG1_Y_ENABLE | REG1_X_ENABLE; - - if (frequency == 0) { - frequency = _is_l3g4200d ? 800 : 760; - } - - /* - * Use limits good for H or non-H models. Rates are slightly different - * for L3G4200D part but register settings are the same. - */ - if (frequency <= 100) { - _current_rate = _is_l3g4200d ? 100 : 95; - bits |= RATE_95HZ_LP_25HZ; - - } else if (frequency <= 200) { - _current_rate = _is_l3g4200d ? 200 : 190; - bits |= RATE_190HZ_LP_50HZ; - - } else if (frequency <= 400) { - _current_rate = _is_l3g4200d ? 400 : 380; - bits |= RATE_380HZ_LP_50HZ; - - } else if (frequency <= 800) { - _current_rate = _is_l3g4200d ? 800 : 760; - bits |= RATE_760HZ_LP_50HZ; - - } else { - return -EINVAL; - } - - write_checked_reg(ADDR_CTRL_REG1, bits); - - return OK; -} - -void -L3GD20::start() -{ - /* make sure we are stopped first */ - stop(); - - /* start polling at the specified rate */ - uint64_t interval = 1000000 / L3G4200D_DEFAULT_RATE; - ScheduleOnInterval(interval - L3GD20_TIMER_REDUCTION, 10000); -} - -void -L3GD20::stop() -{ - ScheduleClear(); -} - -void -L3GD20::disable_i2c(void) -{ - uint8_t retries = 10; - - while (retries--) { - // add retries - uint8_t a = read_reg(0x05); - write_reg(0x05, (0x20 | a)); - - if (read_reg(0x05) == (a | 0x20)) { - // this sets the I2C_DIS bit on the - // L3GD20H. The l3gd20 datasheet doesn't - // mention this register, but it does seem to - // accept it. - write_checked_reg(ADDR_LOW_ODR, 0x08); - return; - } - } - - DEVICE_DEBUG("FAILED TO DISABLE I2C"); -} - -void -L3GD20::reset() -{ - // ensure the chip doesn't interpret any other bus traffic as I2C - disable_i2c(); - - /* set default configuration */ - write_checked_reg(ADDR_CTRL_REG1, REG1_POWER_NORMAL | REG1_Z_ENABLE | REG1_Y_ENABLE | REG1_X_ENABLE); - write_checked_reg(ADDR_CTRL_REG2, 0); /* disable high-pass filters */ - write_checked_reg(ADDR_CTRL_REG3, 0x08); /* DRDY enable */ - write_checked_reg(ADDR_CTRL_REG4, REG4_BDU); - write_checked_reg(ADDR_CTRL_REG5, 0); - write_checked_reg(ADDR_CTRL_REG5, REG5_FIFO_ENABLE); /* disable wake-on-interrupt */ - - /* disable FIFO. This makes things simpler and ensures we - * aren't getting stale data. It means we must run the hrt - * callback fast enough to not miss data. */ - write_checked_reg(ADDR_FIFO_CTRL_REG, FIFO_CTRL_BYPASS_MODE); - - set_samplerate(0); // 760Hz or 800Hz - set_range(L3GD20_DEFAULT_RANGE_DPS); - - _read = 0; -} - -void -L3GD20::Run() -{ - /* make another measurement */ - measure(); -} - -void -L3GD20::check_registers(void) -{ - uint8_t v; - - if ((v = read_reg(_checked_registers[_checked_next])) != _checked_values[_checked_next]) { - /* - if we get the wrong value then we know the SPI bus - or sensor is very sick. We set _register_wait to 20 - and wait until we have seen 20 good values in a row - before we consider the sensor to be OK again. - */ - perf_count(_bad_registers); - - /* - try to fix the bad register value. We only try to - fix one per loop to prevent a bad sensor hogging the - bus. We skip zero as that is the WHO_AM_I, which - is not writeable - */ - if (_checked_next != 0) { - write_reg(_checked_registers[_checked_next], _checked_values[_checked_next]); - } - - _register_wait = 20; - } - - _checked_next = (_checked_next + 1) % L3GD20_NUM_CHECKED_REGISTERS; -} - -void -L3GD20::measure() -{ - /* status register and data as read back from the device */ -#pragma pack(push, 1) - struct { - uint8_t cmd; - int8_t temp; - uint8_t status; - int16_t x; - int16_t y; - int16_t z; - } raw_report{}; -#pragma pack(pop) - - /* start the performance counter */ - perf_begin(_sample_perf); - - check_registers(); - - /* fetch data from the sensor */ - const hrt_abstime timestamp_sample = hrt_absolute_time(); - raw_report.cmd = ADDR_OUT_TEMP | DIR_READ | ADDR_INCREMENT; - transfer((uint8_t *)&raw_report, (uint8_t *)&raw_report, sizeof(raw_report)); - - if (!(raw_report.status & STATUS_ZYXDA)) { - perf_end(_sample_perf); - perf_count(_duplicates); - return; - } - - /* - * 1) Scale raw value to SI units using scaling from datasheet. - * 2) Subtract static offset (in SI units) - * 3) Scale the statically calibrated values with a linear - * dynamically obtained factor - * - * Note: the static sensor offset is the number the sensor outputs - * at a nominally 'zero' input. Therefore the offset has to - * be subtracted. - * - * Example: A gyro outputs a value of 74 at zero angular rate - * the offset is 74 from the origin and subtracting - * 74 from all measurements centers them around zero. - */ - _px4_gyro.set_error_count(perf_event_count(_bad_registers)); - - _px4_gyro.set_temperature(L3GD20_TEMP_OFFSET_CELSIUS - raw_report.temp); - - switch (_orientation) { - case SENSOR_BOARD_ROTATION_090_DEG: - /* swap x and y */ - _px4_gyro.update(timestamp_sample, raw_report.y, raw_report.x, raw_report.z); - break; - - case SENSOR_BOARD_ROTATION_180_DEG: { - /* swap x and y and negate both */ - int16_t x = ((raw_report.x == -32768) ? 32767 : -raw_report.x); - int16_t y = ((raw_report.y == -32768) ? 32767 : -raw_report.y); - _px4_gyro.update(timestamp_sample, x, y, raw_report.z); - } - - break; - - case SENSOR_BOARD_ROTATION_270_DEG: { - /* swap x and y and negate y */ - int16_t x = raw_report.y; - int16_t y = ((raw_report.x == -32768) ? 32767 : -raw_report.x); - _px4_gyro.update(timestamp_sample, x, y, raw_report.z); - } - break; - - case SENSOR_BOARD_ROTATION_000_DEG: - - // FALLTHROUGH - default: - // keep axes in place - _px4_gyro.update(timestamp_sample, raw_report.x, raw_report.y, raw_report.z); - } - - _read++; - - /* stop the perf counter */ - perf_end(_sample_perf); -} - -void -L3GD20::print_info() -{ - printf("gyro reads: %u\n", _read); - perf_print_counter(_sample_perf); - perf_print_counter(_errors); - perf_print_counter(_bad_registers); - perf_print_counter(_duplicates); - - ::printf("checked_next: %u\n", _checked_next); - - for (uint8_t i = 0; i < L3GD20_NUM_CHECKED_REGISTERS; i++) { - uint8_t v = read_reg(_checked_registers[i]); - - if (v != _checked_values[i]) { - ::printf("reg %02x:%02x should be %02x\n", - (unsigned)_checked_registers[i], - (unsigned)v, - (unsigned)_checked_values[i]); - } - } - - _px4_gyro.print_status(); -} - -void -L3GD20::print_registers() -{ - printf("L3GD20 registers\n"); - - for (uint8_t reg = 0; reg <= 0x40; reg++) { - uint8_t v = read_reg(reg); - printf("%02x:%02x ", (unsigned)reg, (unsigned)v); - - if ((reg + 1) % 16 == 0) { - printf("\n"); - } - } - - printf("\n"); -} - -void -L3GD20::test_error() -{ - // trigger a deliberate error - write_reg(ADDR_CTRL_REG3, 0); -} - -/** - * Local functions in support of the shell command. - */ -namespace l3gd20 -{ - -L3GD20 *g_dev; - -void usage(); -void start(bool external_bus, enum Rotation rotation); -void info(); -void regdump(); -void test_error(); - -/** - * Start the driver. - * - * This function call only returns once the driver - * started or failed to detect the sensor. - */ -void -start(bool external_bus, enum Rotation rotation) -{ - if (g_dev != nullptr) { - errx(0, "already started"); - } - - /* create the driver */ - if (external_bus) { -#if defined(PX4_SPI_BUS_EXT) && defined(PX4_SPIDEV_EXT_GYRO) - g_dev = new L3GD20(PX4_SPI_BUS_EXT, L3GD20_DEVICE_PATH, PX4_SPIDEV_EXT_GYRO, rotation); -#else - errx(0, "External SPI not available"); -#endif - - } else { - g_dev = new L3GD20(PX4_SPI_BUS_SENSORS, L3GD20_DEVICE_PATH, PX4_SPIDEV_GYRO, rotation); - } - - if (g_dev == nullptr) { - goto fail; - } - - if (OK != g_dev->init()) { - goto fail; - } - - exit(0); -fail: - - if (g_dev != nullptr) { - delete g_dev; - g_dev = nullptr; - } - - errx(1, "driver start failed"); -} - -/** - * Print a little info about the driver. - */ -void -info() -{ - if (g_dev == nullptr) { - errx(1, "driver not running\n"); - } - - printf("state @ %p\n", g_dev); - g_dev->print_info(); - - exit(0); -} - -/** - * Dump the register information - */ -void -regdump(void) -{ - if (g_dev == nullptr) { - errx(1, "driver not running"); - } - - printf("regdump @ %p\n", g_dev); - g_dev->print_registers(); - - exit(0); -} - -/** - * trigger an error - */ -void -test_error(void) -{ - if (g_dev == nullptr) { - errx(1, "driver not running"); - } - - printf("regdump @ %p\n", g_dev); - g_dev->test_error(); - - exit(0); -} - -void -usage() -{ - warnx("missing command: try 'start', 'info', 'testerror' or 'regdump'"); - warnx("options:"); - warnx(" -X (external bus)"); - warnx(" -R rotation"); -} - -} // namespace - -int -l3gd20_main(int argc, char *argv[]) -{ - int myoptind = 1; - int ch; - const char *myoptarg = nullptr; - bool external_bus = false; - enum Rotation rotation = ROTATION_NONE; - - while ((ch = px4_getopt(argc, argv, "XR:", &myoptind, &myoptarg)) != EOF) { - switch (ch) { - case 'X': - external_bus = true; - break; - - case 'R': - rotation = (enum Rotation)atoi(myoptarg); - break; - - default: - l3gd20::usage(); - return 0; - } - } - - if (myoptind >= argc) { - l3gd20::usage(); - return -1; - } - - const char *verb = argv[myoptind]; - - /* - * Start/load the driver. - - */ - if (!strcmp(verb, "start")) { - l3gd20::start(external_bus, rotation); - } - - /* - * Print driver information. - */ - if (!strcmp(verb, "info")) { - l3gd20::info(); - } - - /* - * Print register information. - */ - if (!strcmp(verb, "regdump")) { - l3gd20::regdump(); - } - - /* - * trigger an error - */ - if (!strcmp(verb, "testerror")) { - l3gd20::test_error(); - } - - PX4_ERR("unrecognized command, try 'start', 'test', 'reset', 'info', 'testerror' or 'regdump'"); - return -1; -} diff --git a/src/drivers/imu/l3gd20/l3gd20_main.cpp b/src/drivers/imu/l3gd20/l3gd20_main.cpp new file mode 100644 index 0000000000..baf4fcf289 --- /dev/null +++ b/src/drivers/imu/l3gd20/l3gd20_main.cpp @@ -0,0 +1,193 @@ +/**************************************************************************** + * + * Copyright (c) 2012-2019 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. + * + ****************************************************************************/ + +#include "L3GD20.hpp" + +/** + * Local functions in support of the shell command. + */ +namespace l3gd20 +{ + +L3GD20 *g_dev{nullptr}; + +/** + * Start the driver. + * + * This function call only returns once the driver + * started or failed to detect the sensor. + */ +static void start(bool external_bus, enum Rotation rotation) +{ + if (g_dev != nullptr) { + errx(0, "already started"); + } + + /* create the driver */ + if (external_bus) { +#if defined(PX4_SPI_BUS_EXT) && defined(PX4_SPIDEV_EXT_GYRO) + g_dev = new L3GD20(PX4_SPI_BUS_EXT, PX4_SPIDEV_EXT_GYRO, rotation); +#else + errx(0, "External SPI not available"); +#endif + + } else { + g_dev = new L3GD20(PX4_SPI_BUS_SENSORS, PX4_SPIDEV_GYRO, rotation); + } + + if (g_dev == nullptr) { + goto fail; + } + + if (OK != g_dev->init()) { + goto fail; + } + + exit(0); +fail: + + if (g_dev != nullptr) { + delete g_dev; + g_dev = nullptr; + } + + errx(1, "driver start failed"); +} + +/** + * Print a little info about the driver. + */ +static void info() +{ + if (g_dev == nullptr) { + errx(1, "driver not running\n"); + } + + printf("state @ %p\n", g_dev); + g_dev->print_info(); + + exit(0); +} + +/** + * Dump the register information + */ +static void regdump() +{ + if (g_dev == nullptr) { + errx(1, "driver not running"); + } + + printf("regdump @ %p\n", g_dev); + g_dev->print_registers(); + + exit(0); +} + +/** + * trigger an error + */ +static void test_error() +{ + if (g_dev == nullptr) { + errx(1, "driver not running"); + } + + printf("regdump @ %p\n", g_dev); + g_dev->test_error(); + + exit(0); +} + +static void usage() +{ + warnx("missing command: try 'start', 'info', 'testerror' or 'regdump'"); + warnx("options:"); + warnx(" -X (external bus)"); + warnx(" -R rotation"); +} + +} // namespace + +extern "C" __EXPORT int l3gd20_main(int argc, char *argv[]) +{ + int myoptind = 1; + int ch; + const char *myoptarg = nullptr; + bool external_bus = false; + enum Rotation rotation = ROTATION_NONE; + + while ((ch = px4_getopt(argc, argv, "XR:", &myoptind, &myoptarg)) != EOF) { + switch (ch) { + case 'X': + external_bus = true; + break; + + case 'R': + rotation = (enum Rotation)atoi(myoptarg); + break; + + default: + l3gd20::usage(); + return 0; + } + } + + if (myoptind >= argc) { + l3gd20::usage(); + return -1; + } + + const char *verb = argv[myoptind]; + + /* + * Start/load the driver. + + */ + if (!strcmp(verb, "start")) { + l3gd20::start(external_bus, rotation); + + } else if (!strcmp(verb, "info")) { + l3gd20::info(); + + } else if (!strcmp(verb, "regdump")) { + l3gd20::regdump(); + + } else if (!strcmp(verb, "testerror")) { + l3gd20::test_error(); + } + + l3gd20::usage(); + + return -1; +}