fly316/PX4-Autopilot
7
0
Fork 0
mirror of https://gitee.com/mirrors_PX4/PX4-Autopilot.git synced 2026-04-14 10:07:39 +08:00
Code Issues Packages Projects Releases Wiki Activity

drivers: use updated I2C SPI driver interface

Browse Source
This commit is contained in:
Beat Küng 2021-04-06 17:40:42 +02:00 committed by Daniel Agar
parent c5aef9d512
commit e644036325
218 changed files with 812 additions and 2001 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/drivers/adc/ads1115/ADS1115.cpp
View File

@ -47,7 +47,18 @@ int ADS1115::init()
config[0] = CONFIG_HIGH_OS_NOACT | CONFIG_HIGH_MUX_P0NG | CONFIG_HIGH_PGA_6144 | CONFIG_HIGH_MODE_SS;
config[1] = CONFIG_LOW_DR_250SPS | CONFIG_LOW_COMP_MODE_TRADITIONAL | CONFIG_LOW_COMP_POL_RESET |
CONFIG_LOW_COMP_LAT_NONE | CONFIG_LOW_COMP_QU_DISABLE;
return writeReg(ADDRESSPOINTER_REG_CONFIG, config, 2);
ret = writeReg(ADDRESSPOINTER_REG_CONFIG, config, 2);
if (ret != PX4_OK) {
PX4_ERR("writeReg failed (%i)", ret);
return ret;
}
setChannel(ADS1115::A0); // prepare for the first measure.
ScheduleOnInterval(SAMPLE_INTERVAL / 4, SAMPLE_INTERVAL / 4);
return PX4_OK;
}
int ADS1115::setChannel(ADS1115::ChannelSelection ch)
@ -194,4 +205,4 @@ int ADS1115::writeReg(uint8_t addr, uint8_t *buf, size_t len)
buffer[0] = addr;
memcpy(buffer + 1, buf, sizeof(uint8_t)*len);
return transfer(buffer, len + 1, nullptr, 0);
}
}

15
src/drivers/adc/ads1115/ADS1115.h
View File

@ -105,24 +105,17 @@ using namespace time_literals;
class ADS1115 : public device::I2C, public I2CSPIDriver<ADS1115>
{
public:
ADS1115(I2CSPIBusOption bus_option, int bus, int addr, int bus_frequency);
ADS1115(const I2CSPIDriverConfig &config);
~ADS1115() override;
int Begin();
int init() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
void RunImpl();
protected:
adc_report_s _adc_report = {};
void print_status() override;
void exit_and_cleanup() override;
@ -133,9 +126,11 @@ private:
static const hrt_abstime SAMPLE_INTERVAL{50_ms};
adc_report_s _adc_report{};
perf_counter_t _cycle_perf;
int _channel_cycle_count = 0;
int _channel_cycle_count{0};
// ADS1115 logic part
enum ChannelSelection {
@ -159,4 +154,4 @@ private:
int writeReg(uint8_t addr, uint8_t *buf, size_t len);
};
};

48
src/drivers/adc/ads1115/ads1115_main.cpp
View File

@ -42,9 +42,9 @@
#include <px4_platform_common/module.h>
#include <drivers/drv_adc.h>
ADS1115::ADS1115(I2CSPIBusOption bus_option, int bus, int addr, int bus_frequency) :
I2C(DRV_ADC_DEVTYPE_ADS1115, nullptr, bus, addr, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, addr),
ADS1115::ADS1115(const I2CSPIDriverConfig &config) :
I2C(config),
I2CSPIDriver(config),
_cycle_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": single-sample"))
{
_adc_report.device_id = this->get_device_id();
@ -63,22 +63,6 @@ ADS1115::~ADS1115()
perf_free(_cycle_perf);
}
int ADS1115::Begin()
{
int ret = init();
if (ret != PX4_OK) {
PX4_ERR("ADS1115 init failed");
return ret;
}
setChannel(ADS1115::A0); // prepare for the first measure.
ScheduleOnInterval(SAMPLE_INTERVAL / 4, SAMPLE_INTERVAL / 4);
return PX4_OK;
}
void ADS1115::exit_and_cleanup()
{
I2CSPIDriverBase::exit_and_cleanup(); // nothing to do
@ -140,25 +124,6 @@ void ADS1115::RunImpl()
perf_end(_cycle_perf);
}
I2CSPIDriverBase *ADS1115::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
ADS1115 *instance = new ADS1115(iterator.configuredBusOption(), iterator.bus(), cli.i2c_address,
cli.bus_frequency);
if (!instance) {
PX4_ERR("alloc failed");
return nullptr;
}
if (OK != instance->Begin()) {
delete instance;
return nullptr;
}
return instance;
}
void ADS1115::print_usage()
{
PRINT_MODULE_USAGE_NAME("ads1115", "driver");
@ -176,17 +141,12 @@ void ADS1115::print_status()
extern "C" int ads1115_main(int argc, char *argv[])
{
int ch;
using ThisDriver = ADS1115;
BusCLIArguments cli{true, false};
cli.default_i2c_frequency = 400000;
cli.i2c_address = 0x48;
while ((ch = cli.getOpt(argc, argv, "")) != EOF) {
}
const char *verb = cli.optArg();
const char *verb = cli.parseDefaultArguments(argc, argv);
if (!verb) {
ThisDriver::print_usage();

5
src/drivers/barometer/bmp280/BMP280.cpp
View File

@ -33,9 +33,8 @@
#include "BMP280.hpp"
BMP280::BMP280(I2CSPIBusOption bus_option, int bus, bmp280::IBMP280 *interface) :
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus,
interface->get_device_address()),
BMP280::BMP280(const I2CSPIDriverConfig &config, bmp280::IBMP280 *interface) :
I2CSPIDriver(config),
_px4_baro(interface->get_device_id()),
_interface(interface),
_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": sample")),

5
src/drivers/barometer/bmp280/BMP280.hpp
View File

@ -45,11 +45,10 @@
class BMP280 : public I2CSPIDriver<BMP280>
{
public:
BMP280(I2CSPIBusOption bus_option, int bus, bmp280::IBMP280 *interface);
BMP280(const I2CSPIDriverConfig &config, bmp280::IBMP280 *interface);
virtual ~BMP280();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
int init();

17
src/drivers/barometer/bmp280/bmp280_main.cpp
View File

@ -50,30 +50,29 @@ BMP280::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *BMP280::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *BMP280::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
bmp280::IBMP280 *interface = nullptr;
if (iterator.busType() == BOARD_I2C_BUS) {
interface = bmp280_i2c_interface(iterator.bus(), cli.i2c_address, cli.bus_frequency);
if (config.bus_type == BOARD_I2C_BUS) {
interface = bmp280_i2c_interface(config.bus, config.i2c_address, config.bus_frequency);
} else if (iterator.busType() == BOARD_SPI_BUS) {
interface = bmp280_spi_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
} else if (config.bus_type == BOARD_SPI_BUS) {
interface = bmp280_spi_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
}
if (interface == nullptr) {
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
if (interface->init() != OK) {
delete interface;
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
BMP280 *dev = new BMP280(iterator.configuredBusOption(), iterator.bus(), interface);
BMP280 *dev = new BMP280(config, interface);
if (dev == nullptr) {
delete interface;

5
src/drivers/barometer/bmp388/bmp388.cpp
View File

@ -41,9 +41,8 @@
#include "bmp388.h"
BMP388::BMP388(I2CSPIBusOption bus_option, int bus, IBMP388 *interface) :
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus,
interface->get_device_address()),
BMP388::BMP388(const I2CSPIDriverConfig &config, IBMP388 *interface) :
I2CSPIDriver(config),
_px4_baro(interface->get_device_id()),
_interface(interface),
_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),

5
src/drivers/barometer/bmp388/bmp388.h
View File

@ -308,11 +308,10 @@ public:
class BMP388 : public I2CSPIDriver<BMP388>
{
public:
BMP388(I2CSPIBusOption bus_option, int bus, IBMP388 *interface);
BMP388(const I2CSPIDriverConfig &config, IBMP388 *interface);
virtual ~BMP388();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
virtual int init();

17
src/drivers/barometer/bmp388/bmp388_main.cpp
View File

@ -48,30 +48,29 @@ BMP388::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *BMP388::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *BMP388::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
IBMP388 *interface = nullptr;
if (iterator.busType() == BOARD_I2C_BUS) {
interface = bmp388_i2c_interface(iterator.bus(), cli.i2c_address, cli.bus_frequency);
if (config.bus_type == BOARD_I2C_BUS) {
interface = bmp388_i2c_interface(config.bus, config.i2c_address, config.bus_frequency);
} else if (iterator.busType() == BOARD_SPI_BUS) {
interface = bmp388_spi_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
} else if (config.bus_type == BOARD_SPI_BUS) {
interface = bmp388_spi_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
}
if (interface == nullptr) {
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
if (interface->init() != OK) {
delete interface;
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
BMP388 *dev = new BMP388(iterator.configuredBusOption(), iterator.bus(), interface);
BMP388 *dev = new BMP388(config, interface);
if (dev == nullptr) {
delete interface;

5
src/drivers/barometer/dps310/DPS310.cpp
View File

@ -46,9 +46,8 @@ static void getTwosComplement(T &raw, uint8_t length)
}
}
DPS310::DPS310(I2CSPIBusOption bus_option, int bus, device::Device *interface) :
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus,
interface->get_device_address()),
DPS310::DPS310(const I2CSPIDriverConfig &config, device::Device *interface) :
I2CSPIDriver(config),
_px4_barometer(interface->get_device_id()),
_interface(interface),
_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),

5
src/drivers/barometer/dps310/DPS310.hpp
View File

@ -56,11 +56,10 @@ using Infineon_DPS310::Register;
class DPS310 : public I2CSPIDriver<DPS310>
{
public:
DPS310(I2CSPIBusOption bus_option, int bus, device::Device *interface);
DPS310(const I2CSPIDriverConfig &config, device::Device *interface);
virtual ~DPS310();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
int init();

17
src/drivers/barometer/dps310/dps310_main.cpp
View File

@ -55,30 +55,29 @@ DPS310::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *DPS310::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *DPS310::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
device::Device *interface = nullptr;
if (iterator.busType() == BOARD_I2C_BUS) {
interface = DPS310_I2C_interface(iterator.bus(), cli.i2c_address, cli.bus_frequency);
if (config.bus_type == BOARD_I2C_BUS) {
interface = DPS310_I2C_interface(config.bus, config.i2c_address, config.bus_frequency);
} else if (iterator.busType() == BOARD_SPI_BUS) {
interface = DPS310_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
} else if (config.bus_type == BOARD_SPI_BUS) {
interface = DPS310_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
}
if (interface == nullptr) {
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
if (interface->init() != OK) {
delete interface;
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
DPS310 *dev = new DPS310(iterator.configuredBusOption(), iterator.bus(), interface);
DPS310 *dev = new DPS310(config, interface);
if (dev == nullptr) {
delete interface;

4
src/drivers/barometer/lps22hb/LPS22HB.cpp
View File

@ -42,8 +42,8 @@
/* Max measurement rate is 25Hz */
#define LPS22HB_CONVERSION_INTERVAL (1000000 / 25) /* microseconds */
LPS22HB::LPS22HB(I2CSPIBusOption bus_option, int bus, device::Device *interface) :
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus),
LPS22HB::LPS22HB(const I2CSPIDriverConfig &config, device::Device *interface) :
I2CSPIDriver(config),
_px4_baro(interface->get_device_id()),
_interface(interface),
_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),

7
src/drivers/barometer/lps22hb/LPS22HB.hpp
View File

@ -70,6 +70,8 @@ static constexpr uint8_t PRESS_OUT_H = 0x2A;
static constexpr uint8_t TEMP_OUT_L = 0x2B;
static constexpr uint8_t TEMP_OUT_H = 0x2C;
#define LPS22HB_ADDRESS 0x5D
/* interface factories */
extern device::Device *LPS22HB_SPI_interface(int bus, uint32_t devid, int bus_frequency, spi_mode_e spi_mode);
extern device::Device *LPS22HB_I2C_interface(int bus, int bus_frequency);
@ -77,11 +79,10 @@ extern device::Device *LPS22HB_I2C_interface(int bus, int bus_frequency);
class LPS22HB : public I2CSPIDriver<LPS22HB>
{
public:
LPS22HB(I2CSPIBusOption bus_option, int bus, device::Device *interface);
LPS22HB(const I2CSPIDriverConfig &config, device::Device *interface);
virtual ~LPS22HB();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
int init();

2
src/drivers/barometer/lps22hb/LPS22HB_I2C.cpp
View File

@ -41,8 +41,6 @@
#include <drivers/device/i2c.h>
#define LPS22HB_ADDRESS 0x5D
device::Device *LPS22HB_I2C_interface(int bus, int bus_frequency);
class LPS22HB_I2C : public device::I2C

19
src/drivers/barometer/lps22hb/lps22hb_main.cpp
View File

@ -43,30 +43,29 @@ void LPS22HB::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *LPS22HB::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *LPS22HB::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
device::Device *interface = nullptr;
if (iterator.busType() == BOARD_I2C_BUS) {
interface = LPS22HB_I2C_interface(iterator.bus(), cli.bus_frequency);
if (config.bus_type == BOARD_I2C_BUS) {
interface = LPS22HB_I2C_interface(config.bus, config.bus_frequency);
} else if (iterator.busType() == BOARD_SPI_BUS) {
interface = LPS22HB_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
} else if (config.bus_type == BOARD_SPI_BUS) {
interface = LPS22HB_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
}
if (interface == nullptr) {
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
if (interface->init() != OK) {
delete interface;
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
LPS22HB *dev = new LPS22HB(iterator.configuredBusOption(), iterator.bus(), interface);
LPS22HB *dev = new LPS22HB(config, interface);
if (dev == nullptr) {
delete interface;
@ -95,6 +94,8 @@ extern "C" __EXPORT int lps22hb_main(int argc, char *argv[])
return -1;
}
cli.i2c_address = LPS22HB_ADDRESS;
BusInstanceIterator iterator(MODULE_NAME, cli, DRV_BARO_DEVTYPE_LPS22HB);
if (!strcmp(verb, "start")) {

4
src/drivers/barometer/lps25h/LPS25H.cpp
View File

@ -33,8 +33,8 @@
#include "LPS25H.hpp"
LPS25H::LPS25H(I2CSPIBusOption bus_option, int bus, device::Device *interface) :
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus),
LPS25H::LPS25H(const I2CSPIDriverConfig &config, device::Device *interface) :
I2CSPIDriver(config),
_px4_barometer(interface->get_device_id()),
_interface(interface),
_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),

5
src/drivers/barometer/lps25h/LPS25H.hpp
View File

@ -155,11 +155,10 @@
class LPS25H : public I2CSPIDriver<LPS25H>
{
public:
LPS25H(I2CSPIBusOption bus_option, int bus, device::Device *interface);
LPS25H(const I2CSPIDriverConfig &config, device::Device *interface);
~LPS25H() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
int init();

2
src/drivers/barometer/lps25h/lps25h.h
View File

@ -50,6 +50,8 @@
#define ID_WHO_AM_I 0xBD
#define LPS25H_ADDRESS 0x5D
/* interface factories */
extern device::Device *LPS25H_SPI_interface(int bus, uint32_t devid, int bus_frequency, spi_mode_e spi_mode);
extern device::Device *LPS25H_I2C_interface(int bus, int bus_frequency);

2
src/drivers/barometer/lps25h/lps25h_i2c.cpp
View File

@ -41,8 +41,6 @@
#include <drivers/device/i2c.h>
#define LPS25H_ADDRESS 0x5D
device::Device *LPS25H_I2C_interface(int bus, int bus_frequency);
class LPS25H_I2C : public device::I2C

19
src/drivers/barometer/lps25h/lps25h_main.cpp
View File

@ -47,30 +47,29 @@ LPS25H::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *LPS25H::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *LPS25H::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
device::Device *interface = nullptr;
if (iterator.busType() == BOARD_I2C_BUS) {
interface = LPS25H_I2C_interface(iterator.bus(), cli.bus_frequency);
if (config.bus_type == BOARD_I2C_BUS) {
interface = LPS25H_I2C_interface(config.bus, config.bus_frequency);
} else if (iterator.busType() == BOARD_SPI_BUS) {
interface = LPS25H_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
} else if (config.bus_type == BOARD_SPI_BUS) {
interface = LPS25H_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
}
if (interface == nullptr) {
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
if (interface->init() != OK) {
delete interface;
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
LPS25H *dev = new LPS25H(iterator.configuredBusOption(), iterator.bus(), interface);
LPS25H *dev = new LPS25H(config, interface);
if (dev == nullptr) {
delete interface;
@ -99,6 +98,8 @@ extern "C" int lps25h_main(int argc, char *argv[])
return -1;
}
cli.i2c_address = LPS25H_ADDRESS;
BusInstanceIterator iterator(MODULE_NAME, cli, DRV_BARO_DEVTYPE_LPS25H);
if (!strcmp(verb, "start")) {

7
src/drivers/barometer/lps33hw/lps33hw.cpp
View File

@ -47,14 +47,13 @@ static void getTwosComplement(T &raw, uint8_t length)
}
}
LPS33HW::LPS33HW(I2CSPIBusOption bus_option, int bus, device::Device *interface, bool keep_retrying) :
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus,
interface->get_device_address()),
LPS33HW::LPS33HW(const I2CSPIDriverConfig &config, device::Device *interface) :
I2CSPIDriver(config),
_px4_barometer(interface->get_device_id()),
_interface(interface),
_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
_comms_errors(perf_alloc(PC_COUNT, MODULE_NAME": comm errors")),
_keep_retrying(keep_retrying)
_keep_retrying(config.keep_running)
{
}

5
src/drivers/barometer/lps33hw/lps33hw.hpp
View File

@ -55,11 +55,10 @@ using ST_LPS33HW::Register;
class LPS33HW : public I2CSPIDriver<LPS33HW>
{
public:
LPS33HW(I2CSPIBusOption bus_option, int bus, device::Device *interface, bool keep_retrying);
LPS33HW(const I2CSPIDriverConfig &config, device::Device *interface);
virtual ~LPS33HW();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
int init();

17
src/drivers/barometer/lps33hw/lps33hw_main.cpp
View File

@ -56,30 +56,29 @@ LPS33HW::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *LPS33HW::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *LPS33HW::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
device::Device *interface = nullptr;
if (iterator.busType() == BOARD_I2C_BUS) {
interface = LPS33HW_I2C_interface(iterator.bus(), cli.i2c_address, cli.bus_frequency);
if (config.bus_type == BOARD_I2C_BUS) {
interface = LPS33HW_I2C_interface(config.bus, config.i2c_address, config.bus_frequency);
} else if (iterator.busType() == BOARD_SPI_BUS) {
interface = LPS33HW_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
} else if (config.bus_type == BOARD_SPI_BUS) {
interface = LPS33HW_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
}
if (interface == nullptr) {
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_ERR("failed creating interface for bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
if (interface->init() != OK) {
delete interface;
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", iterator.bus(), iterator.devid());
PX4_DEBUG("no device on bus %i (devid 0x%" PRIx32 ")", config.bus, config.spi_devid);
return nullptr;
}
LPS33HW *dev = new LPS33HW(iterator.configuredBusOption(), iterator.bus(), interface, cli.keep_running);
LPS33HW *dev = new LPS33HW(config, interface);
if (dev == nullptr) {
delete interface;

8
src/drivers/barometer/mpl3115a2/MPL3115A2.cpp
View File

@ -33,8 +33,6 @@
#include "MPL3115A2.hpp"
#define MPL3115A2_ADDRESS 0x60
#define MPL3115A2_REG_WHO_AM_I 0x0c
#define MPL3115A2_WHO_AM_I 0xC4
@ -54,9 +52,9 @@
#define MPL3115A2_OSR 2 /* Over Sample rate of 4 18MS Minimum time between data samples */
#define MPL3115A2_CTRL_TRIGGER (CTRL_REG1_OST | CTRL_REG1_OS(MPL3115A2_OSR))
MPL3115A2::MPL3115A2(I2CSPIBusOption bus_option, const int bus, int bus_frequency) :
I2C(DRV_BARO_DEVTYPE_MPL3115A2, MODULE_NAME, bus, MPL3115A2_ADDRESS, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
MPL3115A2::MPL3115A2(const I2CSPIDriverConfig &config) :
I2C(config),
I2CSPIDriver(config),
_px4_barometer(get_device_id()),
_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
_measure_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": measure")),

6
src/drivers/barometer/mpl3115a2/MPL3115A2.hpp
View File

@ -48,14 +48,14 @@
#include <px4_platform_common/log.h>
#include <px4_platform_common/i2c_spi_buses.h>
#define MPL3115A2_ADDRESS 0x60
class MPL3115A2 : public device::I2C, public I2CSPIDriver<MPL3115A2>
{
public:
MPL3115A2(I2CSPIBusOption bus_option, const int bus, int bus_frequency);
MPL3115A2(const I2CSPIDriverConfig &config);
~MPL3115A2() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();

19
src/drivers/barometer/mpl3115a2/mpl3115a2_main.cpp
View File

@ -43,31 +43,16 @@ MPL3115A2::print_usage()
PRINT_MODULE_USAGE_SUBCATEGORY("baro");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x60);
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *MPL3115A2::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
MPL3115A2 *dev = new MPL3115A2(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency);
if (dev == nullptr) {
return nullptr;
}
if (OK != dev->init()) {
delete dev;
return nullptr;
}
return dev;
}
extern "C" int mpl3115a2_main(int argc, char *argv[])
{
using ThisDriver = MPL3115A2;
BusCLIArguments cli{true, false};
cli.default_i2c_frequency = 400000;
cli.i2c_address = MPL3115A2_ADDRESS;
const char *verb = cli.parseDefaultArguments(argc, argv);

6
src/drivers/barometer/ms5611/MS5611.hpp
View File

@ -87,12 +87,10 @@ enum MS56XX_DEVICE_TYPES {
class MS5611 : public I2CSPIDriver<MS5611>
{
public:
MS5611(device::Device *interface, ms5611::prom_u &prom_buf, enum MS56XX_DEVICE_TYPES device_type,
I2CSPIBusOption bus_option, int bus);
MS5611(device::Device *interface, ms5611::prom_u &prom_buf, const I2CSPIDriverConfig &config);
~MS5611() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
int init();

16
src/drivers/barometer/ms5611/ms5611.cpp
View File

@ -41,17 +41,25 @@
#include <cdev/CDev.hpp>
MS5611::MS5611(device::Device *interface, ms5611::prom_u &prom_buf, enum MS56XX_DEVICE_TYPES device_type,
I2CSPIBusOption bus_option, int bus) :
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus, 0, device_type),
MS5611::MS5611(device::Device *interface, ms5611::prom_u &prom_buf, const I2CSPIDriverConfig &config) :
I2CSPIDriver(config),
_px4_barometer(interface->get_device_id()),
_interface(interface),
_prom(prom_buf.s),
_device_type(device_type),
_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
_measure_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": measure")),
_comms_errors(perf_alloc(PC_COUNT, MODULE_NAME": com_err"))
{
switch (config.devid_driver_index) {
case DRV_BARO_DEVTYPE_MS5611:
_device_type = MS5611_DEVICE;
break;
case DRV_BARO_DEVTYPE_MS5607:
default:
_device_type = MS5607_DEVICE;
break;
}
}
MS5611::~MS5611()

4
src/drivers/barometer/ms5611/ms5611.h
View File

@ -58,6 +58,10 @@
#define IOCTL_RESET 2
#define IOCTL_MEASURE 3
#define MS5611_ADDRESS_1 0x76 /* address select pins pulled high (PX4FMU series v1.6+) */
#define MS5611_ADDRESS_2 0x77 /* address select pins pulled low (PX4FMU prototypes) */
namespace ms5611
{

3
src/drivers/barometer/ms5611/ms5611_i2c.cpp
View File

@ -41,9 +41,6 @@
#include "ms5611.h"
#define MS5611_ADDRESS_1 0x76 /* address select pins pulled high (PX4FMU series v1.6+) */
#define MS5611_ADDRESS_2 0x77 /* address select pins pulled low (PX4FMU prototypes) */
class MS5611_I2C : public device::I2C
{
public:

21
src/drivers/barometer/ms5611/ms5611_main.cpp
View File

@ -40,17 +40,16 @@
#include "MS5611.hpp"
#include "ms5611.h"
I2CSPIDriverBase *MS5611::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *MS5611::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
ms5611::prom_u prom_buf;
device::Device *interface = nullptr;
if (iterator.busType() == BOARD_I2C_BUS) {
interface = MS5611_i2c_interface(prom_buf, iterator.devid(), iterator.bus(), cli.bus_frequency);
if (config.bus_type == BOARD_I2C_BUS) {
interface = MS5611_i2c_interface(prom_buf, config.spi_devid, config.bus, config.bus_frequency);
} else if (iterator.busType() == BOARD_SPI_BUS) {
interface = MS5611_spi_interface(prom_buf, iterator.devid(), iterator.bus(), cli.bus_frequency, cli.spi_mode);
} else if (config.bus_type == BOARD_SPI_BUS) {
interface = MS5611_spi_interface(prom_buf, config.spi_devid, config.bus, config.bus_frequency, config.spi_mode);
}
if (interface == nullptr) {
@ -60,12 +59,11 @@ I2CSPIDriverBase *MS5611::instantiate(const BusCLIArguments &cli, const BusInsta
if (interface->init() != OK) {
delete interface;
PX4_DEBUG("no device on bus %i (devid 0x%x)", iterator.bus(), iterator.devid());
PX4_DEBUG("no device on bus %i (devid 0x%x)", config.bus, config.spi_devid);
return nullptr;
}
MS5611 *dev = new MS5611(interface, prom_buf, (MS56XX_DEVICE_TYPES)cli.type, iterator.configuredBusOption(),
iterator.bus());
MS5611 *dev = new MS5611(interface, prom_buf, config);
if (dev == nullptr) {
delete interface;
@ -95,7 +93,6 @@ extern "C" int ms5611_main(int argc, char *argv[])
using ThisDriver = MS5611;
int ch;
BusCLIArguments cli{true, true};
cli.type = MS5611_DEVICE;
cli.default_i2c_frequency = 400000;
cli.default_spi_frequency = 20 * 1000 * 1000;
uint16_t dev_type_driver = DRV_BARO_DEVTYPE_MS5611;
@ -106,11 +103,9 @@ extern "C" int ms5611_main(int argc, char *argv[])
int val = atoi(cli.optArg());
if (val == 5611) {
cli.type = MS5611_DEVICE;
dev_type_driver = DRV_BARO_DEVTYPE_MS5611;
} else if (val == 5607) {
cli.type = MS5607_DEVICE;
dev_type_driver = DRV_BARO_DEVTYPE_MS5607;
}
}
@ -125,6 +120,8 @@ extern "C" int ms5611_main(int argc, char *argv[])
return -1;
}
cli.i2c_address = MS5611_ADDRESS_1;
BusInstanceIterator iterator(MODULE_NAME, cli, dev_type_driver);
if (!strcmp(verb, "start")) {

12
src/drivers/batt_smbus/batt_smbus.cpp
View File

@ -47,9 +47,8 @@
extern "C" __EXPORT int batt_smbus_main(int argc, char *argv[]);
BATT_SMBUS::BATT_SMBUS(I2CSPIBusOption bus_option, const int bus, SMBus *interface) :
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus,
interface->get_device_address()),
BATT_SMBUS::BATT_SMBUS(const I2CSPIDriverConfig &config, SMBus *interface) :
I2CSPIDriver(config),
_interface(interface)
{
int32_t battsource = 1;
@ -534,15 +533,14 @@ $ batt_smbus -X write_flash 19069 2 27 0
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *BATT_SMBUS::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *BATT_SMBUS::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
SMBus *interface = new SMBus(DRV_BAT_DEVTYPE_SMBUS, iterator.bus(), cli.i2c_address);
SMBus *interface = new SMBus(DRV_BAT_DEVTYPE_SMBUS, config.bus, config.i2c_address);
if (interface == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
BATT_SMBUS *instance = new BATT_SMBUS(iterator.configuredBusOption(), iterator.bus(), interface);
BATT_SMBUS *instance = new BATT_SMBUS(config, interface);
if (instance == nullptr) {
PX4_ERR("alloc failed");

5
src/drivers/batt_smbus/batt_smbus.h
View File

@ -127,12 +127,11 @@ enum class SMBUS_DEVICE_TYPE {
class BATT_SMBUS : public I2CSPIDriver<BATT_SMBUS>
{
public:
BATT_SMBUS(I2CSPIBusOption bus_option, const int bus, SMBus *interface);
BATT_SMBUS(const I2CSPIDriverConfig &config, SMBus *interface);
~BATT_SMBUS();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
friend SMBus;

46
src/drivers/differential_pressure/ets/ets_airspeed.cpp
View File

@ -63,15 +63,15 @@
class ETSAirspeed : public Airspeed, public I2CSPIDriver<ETSAirspeed>
{
public:
ETSAirspeed(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address = I2C_ADDRESS);
ETSAirspeed(const I2CSPIDriverConfig &config);
virtual ~ETSAirspeed() = default;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
void RunImpl();
int init() override;
protected:
int measure() override;
int collect() override;
@ -82,13 +82,25 @@ protected:
*/
extern "C" __EXPORT int ets_airspeed_main(int argc, char *argv[]);
ETSAirspeed::ETSAirspeed(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address)
: Airspeed(bus, bus_frequency, address, CONVERSION_INTERVAL),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, address)
ETSAirspeed::ETSAirspeed(const I2CSPIDriverConfig &config)
: Airspeed(config.bus, config.bus_frequency, config.i2c_address, CONVERSION_INTERVAL),
I2CSPIDriver(config)
{
_device_id.devid_s.devtype = DRV_DIFF_PRESS_DEVTYPE_MS4525;
}
int ETSAirspeed::init()
{
int ret = Airspeed::init();
if (ret == PX4_OK) {
ScheduleNow();
}
return ret;
}
int
ETSAirspeed::measure()
{
@ -209,26 +221,6 @@ ETSAirspeed::RunImpl()
ScheduleDelayed(CONVERSION_INTERVAL);
}
I2CSPIDriverBase *ETSAirspeed::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
ETSAirspeed *instance = new ETSAirspeed(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->ScheduleNow();
return instance;
}
void
ETSAirspeed::print_usage()
{
@ -236,6 +228,7 @@ ETSAirspeed::print_usage()
PRINT_MODULE_USAGE_SUBCATEGORY("airspeed_sensor");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x75);
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
@ -245,6 +238,7 @@ ets_airspeed_main(int argc, char *argv[])
using ThisDriver = ETSAirspeed;
BusCLIArguments cli{true, false};
cli.default_i2c_frequency = 100000;
cli.i2c_address = I2C_ADDRESS;
const char *verb = cli.parseDefaultArguments(argc, argv);

47
src/drivers/differential_pressure/ms4525/ms4525_airspeed.cpp
View File

@ -77,16 +77,16 @@ enum MS_DEVICE_TYPE {
class MEASAirspeed : public Airspeed, public I2CSPIDriver<MEASAirspeed>
{
public:
MEASAirspeed(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address = I2C_ADDRESS_MS4525DO);
MEASAirspeed(const I2CSPIDriverConfig &config);
virtual ~MEASAirspeed() = default;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
void RunImpl();
int init() override;
protected:
int measure() override;
@ -100,13 +100,24 @@ protected:
*/
extern "C" __EXPORT int ms4525_airspeed_main(int argc, char *argv[]);
MEASAirspeed::MEASAirspeed(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address)
: Airspeed(bus, bus_frequency, address, CONVERSION_INTERVAL),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, address)
MEASAirspeed::MEASAirspeed(const I2CSPIDriverConfig &config)
: Airspeed(config.bus, config.bus_frequency, config.i2c_address, CONVERSION_INTERVAL),
I2CSPIDriver(config)
{
_device_id.devid_s.devtype = DRV_DIFF_PRESS_DEVTYPE_MS4525;
}
int MEASAirspeed::init()
{
int ret = Airspeed::init();
if (ret == PX4_OK) {
ScheduleNow();
}
return ret;
}
int
MEASAirspeed::measure()
{
@ -266,27 +277,6 @@ MEASAirspeed::RunImpl()
ScheduleDelayed(CONVERSION_INTERVAL);
}
I2CSPIDriverBase *MEASAirspeed::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
MEASAirspeed *instance = new MEASAirspeed(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency,
cli.i2c_address);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->ScheduleNow();
return instance;
}
void
MEASAirspeed::print_usage()
{
@ -329,8 +319,7 @@ ms4525_airspeed_main(int argc, char *argv[])
cli.i2c_address = I2C_ADDRESS_MS4515DO;
}
BusInstanceIterator iterator(MODULE_NAME, cli,
DRV_DIFF_PRESS_DEVTYPE_MS4525);
BusInstanceIterator iterator(MODULE_NAME, cli, DRV_DIFF_PRESS_DEVTYPE_MS4525);
if (!strcmp(verb, "start")) {
return ThisDriver::module_start(cli, iterator);

11
src/drivers/differential_pressure/ms5525/MS5525.cpp
View File

@ -33,6 +33,17 @@
#include "MS5525.hpp"
int MS5525::init()
{
int ret = Airspeed::init();
if (ret == PX4_OK) {
ScheduleNow();
}
return ret;
}
int
MS5525::measure()
{

10
src/drivers/differential_pressure/ms5525/MS5525.hpp
View File

@ -51,20 +51,20 @@ static constexpr int64_t CONVERSION_INTERVAL = (1000000 / MEAS_RATE); /* microse
class MS5525 : public Airspeed, public I2CSPIDriver<MS5525>
{
public:
MS5525(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address = I2C_ADDRESS_1_MS5525DSO) :
Airspeed(bus, bus_frequency, address, CONVERSION_INTERVAL),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, address)
MS5525(const I2CSPIDriverConfig &config) :
Airspeed(config.bus, config.bus_frequency, config.i2c_address, CONVERSION_INTERVAL),
I2CSPIDriver(config)
{
}
virtual ~MS5525() = default;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
void RunImpl();
int init() override;
private:
int measure() override;

25
src/drivers/differential_pressure/ms5525/MS5525_main.cpp
View File

@ -35,26 +35,6 @@
extern "C" __EXPORT int ms5525_airspeed_main(int argc, char *argv[]);
I2CSPIDriverBase *MS5525::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
MS5525 *instance = new MS5525(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->ScheduleNow();
return instance;
}
void
MS5525::print_usage()
{
@ -62,6 +42,7 @@ MS5525::print_usage()
PRINT_MODULE_USAGE_SUBCATEGORY("airspeed_sensor");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x76);
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
@ -71,6 +52,7 @@ ms5525_airspeed_main(int argc, char *argv[])
using ThisDriver = MS5525;
BusCLIArguments cli{true, false};
cli.default_i2c_frequency = 100000;
cli.i2c_address = I2C_ADDRESS_1_MS5525DSO;
const char *verb = cli.parseDefaultArguments(argc, argv);
@ -79,8 +61,7 @@ ms5525_airspeed_main(int argc, char *argv[])
return -1;
}
BusInstanceIterator iterator(MODULE_NAME, cli,
DRV_DIFF_PRESS_DEVTYPE_MS5525);
BusInstanceIterator iterator(MODULE_NAME, cli, DRV_DIFF_PRESS_DEVTYPE_MS5525);
if (!strcmp(verb, "start")) {
return ThisDriver::module_start(cli, iterator);

12
src/drivers/differential_pressure/sdp3x/SDP3X.cpp
View File

@ -124,10 +124,16 @@ SDP3X::read_scale()
return PX4_OK;
}
void SDP3X::start()
int SDP3X::init()
{
// make sure to wait 10ms after configuring the measurement mode
ScheduleDelayed(10_ms);
int ret = Airspeed::init();
if (ret == PX4_OK) {
// make sure to wait 10ms after configuring the measurement mode
ScheduleDelayed(10_ms);
}
return ret;
}
int

13
src/drivers/differential_pressure/sdp3x/SDP3X.hpp
View File

@ -69,23 +69,20 @@
class SDP3X : public Airspeed, public I2CSPIDriver<SDP3X>
{
public:
SDP3X(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address = I2C_ADDRESS_1_SDP3X,
bool keep_retrying = false) :
Airspeed(bus, bus_frequency, address, CONVERSION_INTERVAL),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, address),
_keep_retrying{keep_retrying}
SDP3X(const I2CSPIDriverConfig &config) :
Airspeed(config.bus, config.bus_frequency, config.i2c_address, CONVERSION_INTERVAL),
I2CSPIDriver(config),
_keep_retrying{config.keep_running}
{
}
virtual ~SDP3X() = default;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
void RunImpl();
void start();
int init() override;
private:
enum class State {

21
src/drivers/differential_pressure/sdp3x/SDP3X_main.cpp
View File

@ -35,27 +35,6 @@
extern "C" __EXPORT int sdp3x_airspeed_main(int argc, char *argv[]);
I2CSPIDriverBase *SDP3X::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
SDP3X *instance = new SDP3X(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency, cli.i2c_address,
cli.keep_running);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->start();
return instance;
}
void
SDP3X::print_usage()
{

8
src/drivers/distance_sensor/gy_us42/GY_US42.cpp
View File

@ -33,10 +33,10 @@
#include "GY_US42.hpp"
GY_US42::GY_US42(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency, int address) :
I2C(DRV_DIST_DEVTYPE_GY_US42, MODULE_NAME, bus, address, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_px4_rangefinder(get_device_id(), rotation)
GY_US42::GY_US42(const I2CSPIDriverConfig &config) :
I2C(config),
I2CSPIDriver(config),
_px4_rangefinder(get_device_id(), config.rotation)
{
_px4_rangefinder.set_max_distance(GY_US42_MAX_DISTANCE);
_px4_rangefinder.set_min_distance(GY_US42_MIN_DISTANCE);

5
src/drivers/distance_sensor/gy_us42/GY_US42.hpp
View File

@ -63,12 +63,9 @@
class GY_US42 : public device::I2C, public I2CSPIDriver<GY_US42>
{
public:
GY_US42(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
int address = GY_US42_BASEADDR);
GY_US42(const I2CSPIDriverConfig &config);
~GY_US42() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
int init() override;

22
src/drivers/distance_sensor/gy_us42/GY_US42_main.cpp
View File

@ -47,36 +47,18 @@ GY_US42::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *GY_US42::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
GY_US42 *instance = new GY_US42(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
return instance;
}
extern "C" __EXPORT int gy_us42_main(int argc, char *argv[])
{
int ch;
using ThisDriver = GY_US42;
BusCLIArguments cli{true, false};
cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.default_i2c_frequency = 100000;
while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
switch (ch) {
case 'R':
cli.orientation = atoi(cli.optArg());
cli.rotation = (Rotation)atoi(cli.optArg());
break;
}
}

47
src/drivers/distance_sensor/lightware_laser_i2c/lightware_laser_i2c.cpp
View File

@ -60,13 +60,10 @@ using namespace time_literals;
class LightwareLaser : public device::I2C, public I2CSPIDriver<LightwareLaser>
{
public:
LightwareLaser(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
int address = LIGHTWARE_LASER_BASEADDR);
LightwareLaser(const I2CSPIDriverConfig &config);
~LightwareLaser() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
int init() override;
@ -132,11 +129,10 @@ private:
int _consecutive_errors{0};
};
LightwareLaser::LightwareLaser(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
int address) :
I2C(DRV_DIST_DEVTYPE_LIGHTWARE_LASER, MODULE_NAME, bus, address, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_px4_rangefinder(get_device_id(), rotation)
LightwareLaser::LightwareLaser(const I2CSPIDriverConfig &config) :
I2C(config),
I2CSPIDriver(config),
_px4_rangefinder(get_device_id(), config.rotation)
{
_px4_rangefinder.set_device_type(DRV_DIST_DEVTYPE_LIGHTWARE_LASER);
}
@ -205,7 +201,13 @@ int LightwareLaser::init()
}
/* do I2C init (and probe) first */
return I2C::init();
ret = I2C::init();
if (ret == PX4_OK) {
start();
}
return ret;
}
int LightwareLaser::readRegister(Register reg, uint8_t *data, int len)
@ -422,41 +424,24 @@ Setup/usage information: https://docs.px4.io/master/en/sensor/sfxx_lidar.html
PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x66);
PRINT_MODULE_USAGE_PARAM_INT('R', 25, 0, 25, "Sensor rotation - downward facing by default", true);
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *LightwareLaser::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
LightwareLaser* instance = new LightwareLaser(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->start();
return instance;
}
extern "C" __EXPORT int lightware_laser_i2c_main(int argc, char *argv[])
{
int ch;
using ThisDriver = LightwareLaser;
BusCLIArguments cli{true, false};
cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.default_i2c_frequency = 400000;
cli.i2c_address = LIGHTWARE_LASER_BASEADDR;
while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
switch (ch) {
case 'R':
cli.orientation = atoi(cli.optArg());
cli.rotation = (Rotation)atoi(cli.optArg());
break;
}
}

10
src/drivers/distance_sensor/ll40ls/LidarLiteI2C.cpp
View File

@ -41,11 +41,10 @@
#include "LidarLiteI2C.h"
LidarLiteI2C::LidarLiteI2C(I2CSPIBusOption bus_option, const int bus, const uint8_t orientation, int bus_frequency,
const int address) :
I2C(DRV_RNG_DEVTYPE_LL40LS, MODULE_NAME, bus, address, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_px4_rangefinder(get_device_id(), orientation)
LidarLiteI2C::LidarLiteI2C(const I2CSPIDriverConfig &config) :
I2C(config),
I2CSPIDriver(config),
_px4_rangefinder(get_device_id(), config.rotation)
{
_px4_rangefinder.set_min_distance(LL40LS_MIN_DISTANCE);
_px4_rangefinder.set_max_distance(LL40LS_MAX_DISTANCE);
@ -72,6 +71,7 @@ LidarLiteI2C::init()
return PX4_ERROR;
}
start();
return PX4_OK;
}

5
src/drivers/distance_sensor/ll40ls/LidarLiteI2C.h
View File

@ -94,12 +94,9 @@ static constexpr uint32_t LL40LS_CONVERSION_TIMEOUT{100_ms};
class LidarLiteI2C : public device::I2C, public I2CSPIDriver<LidarLiteI2C>
{
public:
LidarLiteI2C(I2CSPIBusOption bus_option, const int bus, const uint8_t orientation, int bus_frequency,
const int address = LL40LS_BASEADDR);
LidarLiteI2C(const I2CSPIDriverConfig &config);
virtual ~LidarLiteI2C();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();

25
src/drivers/distance_sensor/ll40ls/ll40ls.cpp
View File

@ -64,30 +64,12 @@ Setup/usage information: https://docs.px4.io/master/en/sensor/lidar_lite.html
PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x62);
PRINT_MODULE_USAGE_PARAM_INT('R', 25, 0, 25, "Sensor rotation - downward facing by default", true);
PRINT_MODULE_USAGE_COMMAND("regdump");
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *LidarLiteI2C::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
LidarLiteI2C* instance = new LidarLiteI2C(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->start();
return instance;
}
void
LidarLiteI2C::custom_method(const BusCLIArguments &cli)
{
@ -99,13 +81,14 @@ extern "C" __EXPORT int ll40ls_main(int argc, char *argv[])
int ch;
using ThisDriver = LidarLiteI2C;
BusCLIArguments cli{true, false};
cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.default_i2c_frequency = 100000;
cli.i2c_address = LL40LS_BASEADDR;
while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
switch (ch) {
case 'R':
cli.orientation = (enum Rotation)atoi(cli.optArg());
cli.rotation = (enum Rotation)atoi(cli.optArg());
break;
}
}

35
src/drivers/distance_sensor/mappydot/MappyDot.cpp
View File

@ -144,11 +144,9 @@ using namespace time_literals;
class MappyDot : public device::I2C, public ModuleParams, public I2CSPIDriver<MappyDot>
{
public:
MappyDot(I2CSPIBusOption bus_option, const int bus, int bus_frequency);
MappyDot(const I2CSPIDriverConfig &config);
virtual ~MappyDot();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
/**
@ -221,10 +219,10 @@ private:
};
MappyDot::MappyDot(I2CSPIBusOption bus_option, const int bus, int bus_frequency) :
I2C(DRV_DIST_DEVTYPE_MAPPYDOT, MODULE_NAME, bus, MAPPYDOT_BASE_ADDR, bus_frequency),
MappyDot::MappyDot(const I2CSPIDriverConfig &config) :
I2C(config),
ModuleParams(nullptr),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus)
I2CSPIDriver(config)
{
set_device_type(DRV_DIST_DEVTYPE_MAPPYDOT);
}
@ -382,6 +380,7 @@ MappyDot::init()
PX4_INFO("%i sensors connected", _sensor_count);
start();
return PX4_OK;
}
@ -417,9 +416,6 @@ MappyDot::RunImpl()
void
MappyDot::start()
{
// Fetch parameter values.
ModuleParams::updateParams();
// Schedule the driver to run on a set interval
ScheduleOnInterval(MAPPYDOT_MEASUREMENT_INTERVAL_USEC, 10000);
}
@ -434,25 +430,6 @@ MappyDot::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *MappyDot::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
MappyDot *instance = new MappyDot(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->start();
return instance;
}
extern "C" __EXPORT int mappydot_main(int argc, char *argv[])
{
using ThisDriver = MappyDot;
@ -466,6 +443,8 @@ extern "C" __EXPORT int mappydot_main(int argc, char *argv[])
return -1;
}
cli.i2c_address = MAPPYDOT_BASE_ADDR;
BusInstanceIterator iterator(MODULE_NAME, cli, DRV_DIST_DEVTYPE_MAPPYDOT);
if (!strcmp(verb, "start")) {

39
src/drivers/distance_sensor/mb12xx/mb12xx.cpp
View File

@ -88,14 +88,12 @@ using namespace time_literals;
class MB12XX : public device::I2C, public ModuleParams, public I2CSPIDriver<MB12XX>
{
public:
MB12XX(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address);
MB12XX(const I2CSPIDriverConfig &config);
virtual ~MB12XX();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
virtual int init() override;
int init() override;
/**
* Diagnostics - print some basic information about the driver.
@ -175,10 +173,10 @@ private:
);
};
MB12XX::MB12XX(I2CSPIBusOption bus_option, const int bus, int bus_frequency, int address) :
I2C(DRV_DIST_DEVTYPE_MB12XX, MODULE_NAME, bus, address, bus_frequency),
MB12XX::MB12XX(const I2CSPIDriverConfig &config) :
I2C(config),
ModuleParams(nullptr),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, address)
I2CSPIDriver(config)
{
set_device_type(DRV_DIST_DEVTYPE_MB12XX);
}
@ -319,12 +317,13 @@ MB12XX::init()
return PX4_ERROR;
}
// If more than one sonar is detected, adjust the meaure interval to avoid sensor interference.
// If more than one sonar is detected, adjust the measure interval to avoid sensor interference.
if (_sensor_count > 1) {
_measure_interval = MB12XX_INTERVAL_BETWEEN_SUCCESIVE_FIRES;
}
PX4_INFO("Total sensors connected: %i", _sensor_count);
start();
return PX4_OK;
}
@ -407,26 +406,6 @@ MB12XX::custom_method(const BusCLIArguments &cli)
set_address(cli.i2c_address);
}
I2CSPIDriverBase *MB12XX::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
MB12XX *instance = new MB12XX(iterator.configuredBusOption(), iterator.bus(), cli.bus_frequency, cli.i2c_address);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->start();
return instance;
}
void
MB12XX::print_usage()
{
@ -434,7 +413,6 @@ MB12XX::print_usage()
PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x70);
PRINT_MODULE_USAGE_COMMAND("set_address");
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x70);
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
@ -444,7 +422,6 @@ extern "C" __EXPORT int mb12xx_main(int argc, char *argv[])
{
using ThisDriver = MB12XX;
BusCLIArguments cli{true, false};
cli.i2c_address = MB12XX_BASE_ADDR;
cli.default_i2c_frequency = MB12XX_BUS_SPEED;
const char *verb = cli.parseDefaultArguments(argc, argv);
@ -454,6 +431,8 @@ extern "C" __EXPORT int mb12xx_main(int argc, char *argv[])
return -1;
}
cli.i2c_address = MB12XX_BASE_ADDR;
BusInstanceIterator iterator(MODULE_NAME, cli, DRV_DIST_DEVTYPE_MB12XX);
if (!strcmp(verb, "start")) {

16
src/drivers/distance_sensor/srf02/SRF02.cpp
View File

@ -33,10 +33,10 @@
#include "SRF02.hpp"
SRF02::SRF02(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency, int address) :
I2C(DRV_DIST_DEVTYPE_SRF02, MODULE_NAME, bus, address, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_px4_rangefinder(get_device_id(), rotation)
SRF02::SRF02(const I2CSPIDriverConfig &config) :
I2C(config),
I2CSPIDriver(config),
_px4_rangefinder(get_device_id(), config.rotation)
{
_px4_rangefinder.set_device_type(DRV_DIST_DEVTYPE_SRF02);
_px4_rangefinder.set_rangefinder_type(distance_sensor_s::MAV_DISTANCE_SENSOR_ULTRASOUND);
@ -69,7 +69,13 @@ int SRF02::init()
// XXX we should find out why we need to wait 200 ms here
px4_usleep(200000);
return measure();
int ret = measure();
if (ret == PX4_OK) {
start();
}
return ret;
}
int SRF02::collect()

5
src/drivers/distance_sensor/srf02/SRF02.hpp
View File

@ -65,12 +65,9 @@
class SRF02 : public device::I2C, public I2CSPIDriver<SRF02>
{
public:
SRF02(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
int address = SRF02_BASEADDR);
SRF02(const I2CSPIDriverConfig &config);
~SRF02() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
int init() override;

25
src/drivers/distance_sensor/srf02/srf02_main.cpp
View File

@ -43,41 +43,24 @@ SRF02::print_usage()
PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x70);
PRINT_MODULE_USAGE_PARAM_INT('R', 25, 0, 25, "Sensor rotation - downward facing by default", true);
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *SRF02::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
SRF02 *instance = new SRF02(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->start();
return instance;
}
extern "C" __EXPORT int srf02_main(int argc, char *argv[])
{
int ch;
using ThisDriver = SRF02;
BusCLIArguments cli{true, false};
cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.default_i2c_frequency = 100000;
cli.i2c_address = SRF02_BASEADDR;
while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
switch (ch) {
case 'R':
cli.orientation = atoi(cli.optArg());
cli.rotation = (Rotation)atoi(cli.optArg());
break;
}
}

10
src/drivers/distance_sensor/teraranger/TERARANGER.cpp
View File

@ -73,10 +73,10 @@ static uint8_t crc8(uint8_t *p, uint8_t len)
return crc & 0xFF;
}
TERARANGER::TERARANGER(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency) :
I2C(DRV_DIST_DEVTYPE_TERARANGER, MODULE_NAME, bus, TERARANGER_ONE_BASEADDR, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_px4_rangefinder(get_device_id(), rotation)
TERARANGER::TERARANGER(const I2CSPIDriverConfig &config) :
I2C(config),
I2CSPIDriver(config),
_px4_rangefinder(get_device_id(), config.rotation)
{
// up the retries since the device misses the first measure attempts
I2C::_retries = 3;
@ -212,6 +212,8 @@ int TERARANGER::init()
return PX4_ERROR;
}
start();
return PX4_OK;
}

4
src/drivers/distance_sensor/teraranger/TERARANGER.hpp
View File

@ -75,11 +75,9 @@ using namespace time_literals;
class TERARANGER : public device::I2C, public I2CSPIDriver<TERARANGER>
{
public:
TERARANGER(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency);
TERARANGER(const I2CSPIDriverConfig &config);
~TERARANGER() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
virtual int init() override;

25
src/drivers/distance_sensor/teraranger/teraranger_main.cpp
View File

@ -53,41 +53,24 @@ Setup/usage information: https://docs.px4.io/master/en/sensor/rangefinders.html#
PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x30);
PRINT_MODULE_USAGE_PARAM_INT('R', 25, 0, 25, "Sensor rotation - downward facing by default", true);
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *TERARANGER::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
TERARANGER *instance = new TERARANGER(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->start();
return instance;
}
extern "C" __EXPORT int teraranger_main(int argc, char *argv[])
{
int ch;
using ThisDriver = TERARANGER;
BusCLIArguments cli{true, false};
cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.default_i2c_frequency = 100000;
cli.i2c_address = TERARANGER_ONE_BASEADDR;
while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
switch (ch) {
case 'R':
cli.orientation = atoi(cli.optArg());
cli.rotation = (Rotation)atoi(cli.optArg());
break;
}
}

51
src/drivers/distance_sensor/vl53l0x/VL53L0X.cpp
View File

@ -59,10 +59,10 @@
#define VL53L0X_BUS_CLOCK 400000 // 400kHz bus clock speed
VL53L0X::VL53L0X(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency, int address) :
I2C(DRV_DIST_DEVTYPE_VL53L0X, MODULE_NAME, bus, address, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_px4_rangefinder(get_device_id(), rotation)
VL53L0X::VL53L0X(const I2CSPIDriverConfig &config) :
I2C(config),
I2CSPIDriver(config),
_px4_rangefinder(get_device_id(), config.rotation)
{
// VL53L0X typical range 0-2 meters with 25 degree field of view
_px4_rangefinder.set_min_distance(0.f);
@ -82,6 +82,18 @@ VL53L0X::~VL53L0X()
perf_free(_comms_errors);
}
int VL53L0X::init()
{
int ret = I2C::init();
if (ret != PX4_OK) {
return ret;
}
ScheduleNow();
return PX4_OK;
}
int VL53L0X::collect()
{
// Read from the sensor.
@ -489,12 +501,6 @@ int VL53L0X::singleRefCalibration(const uint8_t byte)
return PX4_OK;
}
void VL53L0X::start()
{
// Schedule the first cycle.
ScheduleNow();
}
int VL53L0X::writeRegister(const uint8_t reg_address, const uint8_t value)
{
uint8_t cmd[2] {reg_address, value};
@ -537,41 +543,24 @@ void VL53L0X::print_usage()
PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x29);
PRINT_MODULE_USAGE_PARAM_INT('R', 25, 0, 25, "Sensor rotation - downward facing by default", true);
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *VL53L0X::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
VL53L0X *instance = new VL53L0X(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->start();
return instance;
}
extern "C" __EXPORT int vl53l0x_main(int argc, char *argv[])
{
int ch;
using ThisDriver = VL53L0X;
BusCLIArguments cli{true, false};
cli.default_i2c_frequency = 400000;
cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.i2c_address = VL53L0X_BASEADDR;
while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
switch (ch) {
case 'R':
cli.orientation = atoi(cli.optArg());
cli.rotation = (Rotation)atoi(cli.optArg());
break;
}
}

12
src/drivers/distance_sensor/vl53l0x/VL53L0X.hpp
View File

@ -54,13 +54,10 @@
class VL53L0X : public device::I2C, public I2CSPIDriver<VL53L0X>
{
public:
VL53L0X(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
int address = VL53L0X_BASEADDR);
VL53L0X(const I2CSPIDriverConfig &config);
~VL53L0X() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
/**
@ -68,17 +65,14 @@ public:
*/
void print_status() override;
/**
* Initialise the automatic measurement state machine and start it.
*/
void start();
/**
* Perform a poll cycle; collect from the previous measurement
* and start a new one.
*/
void RunImpl();
int init() override;
private:
int probe() override;

47
src/drivers/distance_sensor/vl53l1x/vl53l1x.cpp
View File

@ -140,10 +140,10 @@ static const uint8_t status_rtn[24] = { 255, 255, 255, 5, 2, 4, 1, 7, 3, 0,
/* end ST */
VL53L1X::VL53L1X(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency, int address) :
I2C(DRV_DIST_DEVTYPE_VL53L1X, MODULE_NAME, bus, address, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_px4_rangefinder(get_device_id(), rotation)
VL53L1X::VL53L1X(const I2CSPIDriverConfig &config) :
I2C(config),
I2CSPIDriver(config),
_px4_rangefinder(get_device_id(), config.rotation)
{
// VL53L1X typical range 0-2 meters with 25 degree field of view
_px4_rangefinder.set_min_distance(0.f);
@ -231,12 +231,6 @@ void VL53L1X::RunImpl()
ScheduleDelayed(VL53L1X_SAMPLE_RATE);
}
void VL53L1X::start()
{
// Schedule the first cycle.
ScheduleNow();
}
int VL53L1X::init()
{
int ret = PX4_OK;
@ -258,21 +252,18 @@ int VL53L1X::init()
return PX4_ERROR;
}
PX4_INFO("vl53l1x init success");
PX4_DEBUG("vl53l1x init success");
ScheduleNow();
return PX4_OK;
}
void VL53L1X::stop()
{
VL53L1X_StopRanging();
}
void VL53L1X::print_usage()
{
PRINT_MODULE_USAGE_NAME("vl53l1x", "driver");
PRINT_MODULE_USAGE_SUBCATEGORY("distance_sensor");
PRINT_MODULE_USAGE_COMMAND("start");
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x29);
PRINT_MODULE_USAGE_PARAM_INT('R', 25, 1, 25, "Sensor rotation - downward facing by default", true);
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
@ -658,37 +649,19 @@ int8_t VL53L1X::VL53L1X_ConfigBig(uint16_t DM, uint16_t TimingBudgetInMs)
/* end ST */
I2CSPIDriverBase *VL53L1X::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
VL53L1X *instance = new VL53L1X(iterator.configuredBusOption(), iterator.bus(), cli.orientation, cli.bus_frequency);
if (instance == nullptr) {
PX4_ERR("alloc failed");
return nullptr;
}
if (instance->init() != PX4_OK) {
delete instance;
return nullptr;
}
instance->start();
return instance;
}
extern "C" __EXPORT int vl53l1x_main(int argc, char *argv[])
{
int ch;
using ThisDriver = VL53L1X;
BusCLIArguments cli{true, false};
cli.default_i2c_frequency = 400000;
cli.orientation = distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.rotation = (Rotation)distance_sensor_s::ROTATION_DOWNWARD_FACING;
cli.i2c_address = VL53L1X_BASEADDR;
while ((ch = cli.getOpt(argc, argv, "R:")) != EOF) {
switch (ch) {
case 'R':
cli.orientation = atoi(cli.optArg());
cli.rotation = (Rotation)atoi(cli.optArg());
break;
}
}

15
src/drivers/distance_sensor/vl53l1x/vl53l1x.hpp
View File

@ -98,13 +98,10 @@
class VL53L1X : public device::I2C, public I2CSPIDriver<VL53L1X>
{
public:
VL53L1X(I2CSPIBusOption bus_option, const int bus, const uint8_t rotation, int bus_frequency,
int address = VL53L1X_BASEADDR);
VL53L1X(const I2CSPIDriverConfig &config);
~VL53L1X() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
/**
@ -112,16 +109,6 @@ public:
*/
void print_status() override;
/**
* Initialise the automatic measurement state machine and start it.
*/
void start();
/**
* Stop the automatic measurement state machine.
*/
void stop();
virtual int init() override;
/**

13
src/drivers/imu/adis16477/ADIS16477.cpp
View File

@ -53,15 +53,14 @@ static constexpr uint32_t ADIS16477_DEFAULT_RATE = 1000;
using namespace time_literals;
ADIS16477::ADIS16477(I2CSPIBusOption bus_option, int bus, int32_t device, enum Rotation rotation, int bus_frequency,
spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
SPI(DRV_IMU_DEVTYPE_ADIS16477, MODULE_NAME, bus, device, spi_mode, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_px4_accel(get_device_id(), rotation),
_px4_gyro(get_device_id(), rotation),
ADIS16477::ADIS16477(const I2CSPIDriverConfig &config) :
SPI(config),
I2CSPIDriver(config),
_px4_accel(get_device_id(), config.rotation),
_px4_gyro(get_device_id(), config.rotation),
_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
_bad_transfers(perf_alloc(PC_COUNT, MODULE_NAME": bad transfers")),
_drdy_gpio(drdy_gpio)
_drdy_gpio(config.drdy_gpio)
{
#ifdef GPIO_SPI1_RESET_ADIS16477
// Configure hardware reset line

5
src/drivers/imu/adis16477/ADIS16477.hpp
View File

@ -50,12 +50,9 @@
class ADIS16477 : public device::SPI, public I2CSPIDriver<ADIS16477>
{
public:
ADIS16477(I2CSPIBusOption bus_option, int bus, int32_t device, enum Rotation rotation, int bus_frequency,
spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
ADIS16477(const I2CSPIDriverConfig &config);
virtual ~ADIS16477();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
int init();

19
src/drivers/imu/adis16477/adis16477_main.cpp
View File

@ -47,25 +47,6 @@ ADIS16477::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *ADIS16477::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
ADIS16477 *instance = new ADIS16477(iterator.configuredBusOption(), iterator.bus(), iterator.devid(), cli.rotation,
cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
if (!instance) {
PX4_ERR("alloc failed");
return nullptr;
}
if (OK != instance->init()) {
delete instance;
return nullptr;
}
return instance;
}
extern "C" int adis16477_main(int argc, char *argv[])
{
int ch;

13
src/drivers/imu/adis16497/ADIS16497.cpp
View File

@ -70,15 +70,14 @@ static constexpr uint32_t ADIS16497_DEFAULT_RATE = 1000;
using namespace time_literals;
ADIS16497::ADIS16497(I2CSPIBusOption bus_option, int bus, int32_t device, enum Rotation rotation, int bus_frequency,
spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
SPI(DRV_IMU_DEVTYPE_ADIS16497, MODULE_NAME, bus, device, spi_mode, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_px4_accel(get_device_id(), rotation),
_px4_gyro(get_device_id(), rotation),
ADIS16497::ADIS16497(const I2CSPIDriverConfig &config) :
SPI(config),
I2CSPIDriver(config),
_px4_accel(get_device_id(), config.rotation),
_px4_gyro(get_device_id(), config.rotation),
_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": read")),
_bad_transfers(perf_alloc(PC_COUNT, MODULE_NAME": bad transfers")),
_drdy_gpio(drdy_gpio)
_drdy_gpio(config.drdy_gpio)
{
#ifdef GPIO_SPI1_RESET_ADIS16497
// Configure hardware reset line

5
src/drivers/imu/adis16497/ADIS16497.hpp
View File

@ -86,12 +86,9 @@ static constexpr uint32_t crc32_tab[] = {
class ADIS16497 : public device::SPI, public I2CSPIDriver<ADIS16497>
{
public:
ADIS16497(I2CSPIBusOption bus_option, int bus, int32_t device, enum Rotation rotation, int bus_frequency,
spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
ADIS16497(const I2CSPIDriverConfig &config);
virtual ~ADIS16497();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
int init() override;

19
src/drivers/imu/adis16497/adis16497_main.cpp
View File

@ -47,25 +47,6 @@ ADIS16497::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *ADIS16497::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
ADIS16497 *instance = new ADIS16497(iterator.configuredBusOption(), iterator.bus(), iterator.devid(), cli.rotation,
cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
if (!instance) {
PX4_ERR("alloc failed");
return nullptr;
}
if (OK != instance->init()) {
delete instance;
return nullptr;
}
return instance;
}
extern "C" int adis16497_main(int argc, char *argv[])
{
int ch;

15
src/drivers/imu/analog_devices/adis16448/ADIS16448.cpp
View File

@ -95,15 +95,14 @@ static int16_t convert12BitToINT16(uint16_t word)
return output;
}
ADIS16448::ADIS16448(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
spi_drdy_gpio_t drdy_gpio) :
SPI(DRV_IMU_DEVTYPE_ADIS16448, MODULE_NAME, bus, device, SPIDEV_MODE3, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_drdy_gpio(drdy_gpio), // TODO: DRDY disabled
_px4_accel(get_device_id(), rotation),
ADIS16448::ADIS16448(const I2CSPIDriverConfig &config) :
SPI(config),
I2CSPIDriver(config),
_drdy_gpio(config.drdy_gpio), // TODO: DRDY disabled
_px4_accel(get_device_id(), config.rotation),
_px4_baro(get_device_id()),
_px4_gyro(get_device_id(), rotation),
_px4_mag(get_device_id(), rotation)
_px4_gyro(get_device_id(), config.rotation),
_px4_mag(get_device_id(), config.rotation)
{
}

5
src/drivers/imu/analog_devices/adis16448/ADIS16448.hpp
View File

@ -58,12 +58,9 @@ using namespace Analog_Devices_ADIS16448;
class ADIS16448 : public device::SPI, public I2CSPIDriver<ADIS16448>
{
public:
ADIS16448(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
spi_drdy_gpio_t drdy_gpio);
ADIS16448(const I2CSPIDriverConfig &config);
~ADIS16448() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
void RunImpl();

19
src/drivers/imu/analog_devices/adis16448/adis16448_main.cpp
View File

@ -46,25 +46,6 @@ void ADIS16448::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *ADIS16448::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
ADIS16448 *instance = new ADIS16448(iterator.configuredBusOption(), iterator.bus(), iterator.devid(), cli.rotation,
cli.bus_frequency, iterator.DRDYGPIO());
if (!instance) {
PX4_ERR("alloc failed");
return nullptr;
}
if (OK != instance->init()) {
delete instance;
return nullptr;
}
return instance;
}
extern "C" int adis16448_main(int argc, char *argv[])
{
int ch;

13
src/drivers/imu/analog_devices/adis16470/ADIS16470.cpp
View File

@ -40,13 +40,12 @@ static constexpr int16_t combine(uint8_t msb, uint8_t lsb)
return (msb << 8u) | lsb;
}
ADIS16470::ADIS16470(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
spi_drdy_gpio_t drdy_gpio) :
SPI(DRV_IMU_DEVTYPE_ADIS16470, MODULE_NAME, bus, device, SPIDEV_MODE3, bus_frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus),
_drdy_gpio(drdy_gpio),
_px4_accel(get_device_id(), rotation),
_px4_gyro(get_device_id(), rotation)
ADIS16470::ADIS16470(const I2CSPIDriverConfig &config) :
SPI(config),
I2CSPIDriver(config),
_drdy_gpio(config.drdy_gpio),
_px4_accel(get_device_id(), config.rotation),
_px4_gyro(get_device_id(), config.rotation)
{
}

5
src/drivers/imu/analog_devices/adis16470/ADIS16470.hpp
View File

@ -56,12 +56,9 @@ using namespace Analog_Devices_ADIS16470;
class ADIS16470 : public device::SPI, public I2CSPIDriver<ADIS16470>
{
public:
ADIS16470(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
spi_drdy_gpio_t drdy_gpio);
ADIS16470(const I2CSPIDriverConfig &config);
~ADIS16470() override;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static void print_usage();
void RunImpl();

19
src/drivers/imu/analog_devices/adis16470/adis16470_main.cpp
View File

@ -46,25 +46,6 @@ void ADIS16470::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *ADIS16470::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
{
ADIS16470 *instance = new ADIS16470(iterator.configuredBusOption(), iterator.bus(), iterator.devid(), cli.rotation,
cli.bus_frequency, iterator.DRDYGPIO());
if (!instance) {
PX4_ERR("alloc failed");
return nullptr;
}
if (OK != instance->init()) {
delete instance;
return nullptr;
}
return instance;
}
extern "C" int adis16470_main(int argc, char *argv[])
{
int ch;

22
src/drivers/imu/bosch/bmi055/BMI055.cpp
View File

@ -36,18 +36,15 @@
#include "BMI055_Accelerometer.hpp"
#include "BMI055_Gyroscope.hpp"
I2CSPIDriverBase *BMI055::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *BMI055::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
BMI055 *instance = nullptr;
if (cli.type == DRV_ACC_DEVTYPE_BMI055) {
instance = new Bosch::BMI055::Accelerometer::BMI055_Accelerometer(iterator.configuredBusOption(), iterator.bus(),
iterator.devid(), cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
if (config.devid_driver_index == DRV_ACC_DEVTYPE_BMI055) {
instance = new Bosch::BMI055::Accelerometer::BMI055_Accelerometer(config);
} else if (cli.type == DRV_GYR_DEVTYPE_BMI055) {
instance = new Bosch::BMI055::Gyroscope::BMI055_Gyroscope(iterator.configuredBusOption(), iterator.bus(),
iterator.devid(), cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
} else if (config.devid_driver_index == DRV_GYR_DEVTYPE_BMI055) {
instance = new Bosch::BMI055::Gyroscope::BMI055_Gyroscope(config);
}
if (!instance) {
@ -63,11 +60,10 @@ I2CSPIDriverBase *BMI055::instantiate(const BusCLIArguments &cli, const BusInsta
return instance;
}
BMI055::BMI055(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device,
enum spi_mode_e mode, uint32_t frequency, spi_drdy_gpio_t drdy_gpio) :
SPI(devtype, name, bus, device, mode, frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, devtype),
_drdy_gpio(drdy_gpio)
BMI055::BMI055(const I2CSPIDriverConfig &config) :
SPI(config),
I2CSPIDriver(config),
_drdy_gpio(config.drdy_gpio)
{
}

6
src/drivers/imu/bosch/bmi055/BMI055.hpp
View File

@ -43,13 +43,11 @@ static constexpr int16_t combine(uint8_t msb, uint8_t lsb) { return (msb << 8u)
class BMI055 : public device::SPI, public I2CSPIDriver<BMI055>
{
public:
BMI055(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device, enum spi_mode_e mode,
uint32_t frequency, spi_drdy_gpio_t drdy_gpio);
BMI055(const I2CSPIDriverConfig &config);
virtual ~BMI055() = default;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
virtual void RunImpl() = 0;

9
src/drivers/imu/bosch/bmi055/BMI055_Accelerometer.cpp
View File

@ -40,12 +40,11 @@ using namespace time_literals;
namespace Bosch::BMI055::Accelerometer
{
BMI055_Accelerometer::BMI055_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
BMI055(DRV_ACC_DEVTYPE_BMI055, "BMI055_Accelerometer", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
_px4_accel(get_device_id(), rotation)
BMI055_Accelerometer::BMI055_Accelerometer(const I2CSPIDriverConfig &config) :
BMI055(config),
_px4_accel(get_device_id(), config.rotation)
{
if (drdy_gpio != 0) {
if (config.drdy_gpio != 0) {
_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_accel: DRDY missed");
}

3
src/drivers/imu/bosch/bmi055/BMI055_Accelerometer.hpp
View File

@ -45,8 +45,7 @@ namespace Bosch::BMI055::Accelerometer
class BMI055_Accelerometer : public BMI055
{
public:
BMI055_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
BMI055_Accelerometer(const I2CSPIDriverConfig &config);
~BMI055_Accelerometer() override;
void RunImpl() override;

9
src/drivers/imu/bosch/bmi055/BMI055_Gyroscope.cpp
View File

@ -40,12 +40,11 @@ using namespace time_literals;
namespace Bosch::BMI055::Gyroscope
{
BMI055_Gyroscope::BMI055_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
BMI055(DRV_GYR_DEVTYPE_BMI055, "BMI055_Gyroscope", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
_px4_gyro(get_device_id(), rotation)
BMI055_Gyroscope::BMI055_Gyroscope(const I2CSPIDriverConfig &config) :
BMI055(config),
_px4_gyro(get_device_id(), config.rotation)
{
if (drdy_gpio != 0) {
if (config.drdy_gpio != 0) {
_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_gyro: DRDY missed");
}

3
src/drivers/imu/bosch/bmi055/BMI055_Gyroscope.hpp
View File

@ -45,8 +45,7 @@ namespace Bosch::BMI055::Gyroscope
class BMI055_Gyroscope : public BMI055
{
public:
BMI055_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
BMI055_Gyroscope(const I2CSPIDriverConfig &config);
~BMI055_Gyroscope() override;
void RunImpl() override;

13
src/drivers/imu/bosch/bmi055/bmi055_main.cpp
View File

@ -53,17 +53,20 @@ extern "C" int bmi055_main(int argc, char *argv[])
int ch;
using ThisDriver = BMI055;
BusCLIArguments cli{false, true};
cli.type = 0;
uint16_t type = 0;
cli.default_spi_frequency = 10000000;
const char *name = MODULE_NAME;
while ((ch = cli.getOpt(argc, argv, "AGR:")) != EOF) {
switch (ch) {
case 'A':
cli.type = DRV_ACC_DEVTYPE_BMI055;
type = DRV_ACC_DEVTYPE_BMI055;
name = MODULE_NAME "_accel";
break;
case 'G':
cli.type = DRV_GYR_DEVTYPE_BMI055;
type = DRV_GYR_DEVTYPE_BMI055;
name = MODULE_NAME "_gyro";
break;
case 'R':
@ -74,12 +77,12 @@ extern "C" int bmi055_main(int argc, char *argv[])
const char *verb = cli.optArg();
if (!verb) {
if (!verb || type == 0) {
ThisDriver::print_usage();
return -1;
}
BusInstanceIterator iterator(MODULE_NAME, cli, cli.type);
BusInstanceIterator iterator(name, cli, type);
if (!strcmp(verb, "start")) {
return ThisDriver::module_start(cli, iterator);

22
src/drivers/imu/bosch/bmi088/BMI088.cpp
View File

@ -36,18 +36,15 @@
#include "BMI088_Accelerometer.hpp"
#include "BMI088_Gyroscope.hpp"
I2CSPIDriverBase *BMI088::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *BMI088::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
BMI088 *instance = nullptr;
if (cli.type == DRV_ACC_DEVTYPE_BMI088) {
instance = new Bosch::BMI088::Accelerometer::BMI088_Accelerometer(iterator.configuredBusOption(), iterator.bus(),
iterator.devid(), cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
if (config.devid_driver_index == DRV_ACC_DEVTYPE_BMI088) {
instance = new Bosch::BMI088::Accelerometer::BMI088_Accelerometer(config);
} else if (cli.type == DRV_GYR_DEVTYPE_BMI088) {
instance = new Bosch::BMI088::Gyroscope::BMI088_Gyroscope(iterator.configuredBusOption(), iterator.bus(),
iterator.devid(), cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
} else if (config.devid_driver_index == DRV_GYR_DEVTYPE_BMI088) {
instance = new Bosch::BMI088::Gyroscope::BMI088_Gyroscope(config);
}
if (!instance) {
@ -63,11 +60,10 @@ I2CSPIDriverBase *BMI088::instantiate(const BusCLIArguments &cli, const BusInsta
return instance;
}
BMI088::BMI088(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device,
enum spi_mode_e mode, uint32_t frequency, spi_drdy_gpio_t drdy_gpio) :
SPI(devtype, name, bus, device, mode, frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, devtype),
_drdy_gpio(drdy_gpio)
BMI088::BMI088(const I2CSPIDriverConfig &config) :
SPI(config),
I2CSPIDriver(config),
_drdy_gpio(config.drdy_gpio)
{
}

6
src/drivers/imu/bosch/bmi088/BMI088.hpp
View File

@ -43,13 +43,11 @@ static constexpr int16_t combine(uint8_t msb, uint8_t lsb) { return (msb << 8u)
class BMI088 : public device::SPI, public I2CSPIDriver<BMI088>
{
public:
BMI088(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device, enum spi_mode_e mode,
uint32_t frequency, spi_drdy_gpio_t drdy_gpio);
BMI088(const I2CSPIDriverConfig &config);
virtual ~BMI088() = default;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
virtual void RunImpl() = 0;

9
src/drivers/imu/bosch/bmi088/BMI088_Accelerometer.cpp
View File

@ -40,12 +40,11 @@ using namespace time_literals;
namespace Bosch::BMI088::Accelerometer
{
BMI088_Accelerometer::BMI088_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
BMI088(DRV_ACC_DEVTYPE_BMI088, "BMI088_Accelerometer", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
_px4_accel(get_device_id(), rotation)
BMI088_Accelerometer::BMI088_Accelerometer(const I2CSPIDriverConfig &config) :
BMI088(config),
_px4_accel(get_device_id(), config.rotation)
{
if (drdy_gpio != 0) {
if (config.drdy_gpio != 0) {
_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_accel: DRDY missed");
}

3
src/drivers/imu/bosch/bmi088/BMI088_Accelerometer.hpp
View File

@ -45,8 +45,7 @@ namespace Bosch::BMI088::Accelerometer
class BMI088_Accelerometer : public BMI088
{
public:
BMI088_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
BMI088_Accelerometer(const I2CSPIDriverConfig &config);
~BMI088_Accelerometer() override;
void RunImpl() override;

9
src/drivers/imu/bosch/bmi088/BMI088_Gyroscope.cpp
View File

@ -40,12 +40,11 @@ using namespace time_literals;
namespace Bosch::BMI088::Gyroscope
{
BMI088_Gyroscope::BMI088_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
BMI088(DRV_GYR_DEVTYPE_BMI088, "BMI088_Gyroscope", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
_px4_gyro(get_device_id(), rotation)
BMI088_Gyroscope::BMI088_Gyroscope(const I2CSPIDriverConfig &config) :
BMI088(config),
_px4_gyro(get_device_id(), config.rotation)
{
if (drdy_gpio != 0) {
if (config.drdy_gpio != 0) {
_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_gyro: DRDY missed");
}

3
src/drivers/imu/bosch/bmi088/BMI088_Gyroscope.hpp
View File

@ -45,8 +45,7 @@ namespace Bosch::BMI088::Gyroscope
class BMI088_Gyroscope : public BMI088
{
public:
BMI088_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
BMI088_Gyroscope(const I2CSPIDriverConfig &config);
~BMI088_Gyroscope() override;
void RunImpl() override;

22
src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088.cpp
View File

@ -36,18 +36,15 @@
#include "BMI088_Accelerometer.hpp"
#include "BMI088_Gyroscope.hpp"
I2CSPIDriverBase *BMI088::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *BMI088::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
BMI088 *instance = nullptr;
if (cli.type == DRV_ACC_DEVTYPE_BMI088) {
instance = new Bosch::BMI088::Accelerometer::BMI088_Accelerometer(iterator.configuredBusOption(), iterator.bus(),
cli.i2c_address, cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
if (config.devid_driver_index == DRV_ACC_DEVTYPE_BMI088) {
instance = new Bosch::BMI088::Accelerometer::BMI088_Accelerometer(config);
} else if (cli.type == DRV_GYR_DEVTYPE_BMI088) {
instance = new Bosch::BMI088::Gyroscope::BMI088_Gyroscope(iterator.configuredBusOption(), iterator.bus(),
cli.i2c_address, cli.rotation, cli.bus_frequency, cli.spi_mode, iterator.DRDYGPIO());
} else if (config.devid_driver_index == DRV_GYR_DEVTYPE_BMI088) {
instance = new Bosch::BMI088::Gyroscope::BMI088_Gyroscope(config);
}
if (!instance) {
@ -63,11 +60,10 @@ I2CSPIDriverBase *BMI088::instantiate(const BusCLIArguments &cli, const BusInsta
return instance;
}
BMI088::BMI088(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device,
enum spi_mode_e mode, uint32_t frequency, spi_drdy_gpio_t drdy_gpio) :
I2C(devtype, name, bus, device, frequency),
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(get_device_id()), bus_option, bus, devtype),
_drdy_gpio(drdy_gpio)
BMI088::BMI088(const I2CSPIDriverConfig &config) :
I2C(config),
I2CSPIDriver(config),
_drdy_gpio(config.drdy_gpio)
{
}

6
src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088.hpp
View File

@ -43,13 +43,11 @@ static constexpr int16_t combine(uint8_t msb, uint8_t lsb) { return (msb << 8u)
class BMI088 : public device::I2C, public I2CSPIDriver<BMI088>
{
public:
BMI088(uint8_t devtype, const char *name, I2CSPIBusOption bus_option, int bus, uint32_t device, enum spi_mode_e mode,
uint32_t frequency, spi_drdy_gpio_t drdy_gpio);
BMI088(const I2CSPIDriverConfig &config);
virtual ~BMI088() = default;
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
virtual void RunImpl() = 0;

9
src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088_Accelerometer.cpp
View File

@ -39,12 +39,11 @@ using namespace time_literals;
namespace Bosch::BMI088::Accelerometer
{
BMI088_Accelerometer::BMI088_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
BMI088(DRV_ACC_DEVTYPE_BMI088, "BMI088_Accelerometer", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
_px4_accel(get_device_id(), rotation)
BMI088_Accelerometer::BMI088_Accelerometer(const I2CSPIDriverConfig &config) :
BMI088(config),
_px4_accel(get_device_id(), config.rotation)
{
if (drdy_gpio != 0) {
if (config.drdy_gpio != 0) {
_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_accel: DRDY missed");
}

3
src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088_Accelerometer.hpp
View File

@ -45,8 +45,7 @@ namespace Bosch::BMI088::Accelerometer
class BMI088_Accelerometer : public BMI088
{
public:
BMI088_Accelerometer(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
BMI088_Accelerometer(const I2CSPIDriverConfig &config);
~BMI088_Accelerometer() override;
void RunImpl() override;

9
src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088_Gyroscope.cpp
View File

@ -40,12 +40,11 @@ using namespace time_literals;
namespace Bosch::BMI088::Gyroscope
{
BMI088_Gyroscope::BMI088_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation,
int bus_frequency, spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio) :
BMI088(DRV_GYR_DEVTYPE_BMI088, "BMI088_Gyroscope", bus_option, bus, device, spi_mode, bus_frequency, drdy_gpio),
_px4_gyro(get_device_id(), rotation)
BMI088_Gyroscope::BMI088_Gyroscope(const I2CSPIDriverConfig &config) :
BMI088(config),
_px4_gyro(get_device_id(), config.rotation)
{
if (drdy_gpio != 0) {
if (config.drdy_gpio != 0) {
_drdy_missed_perf = perf_alloc(PC_COUNT, MODULE_NAME"_gyro: DRDY missed");
}

3
src/drivers/imu/bosch/bmi088/bmi088_i2c/BMI088_Gyroscope.hpp
View File

@ -45,8 +45,7 @@ namespace Bosch::BMI088::Gyroscope
class BMI088_Gyroscope : public BMI088
{
public:
BMI088_Gyroscope(I2CSPIBusOption bus_option, int bus, uint32_t device, enum Rotation rotation, int bus_frequency,
spi_mode_e spi_mode, spi_drdy_gpio_t drdy_gpio);
BMI088_Gyroscope(const I2CSPIDriverConfig &config);
~BMI088_Gyroscope() override;
void RunImpl() override;

17
src/drivers/imu/bosch/bmi088/bmi088_i2c/bmi088_i2c_main.cpp
View File

@ -45,7 +45,7 @@ void BMI088::print_usage()
PRINT_MODULE_USAGE_PARAM_FLAG('A', "Accel", true);
PRINT_MODULE_USAGE_PARAM_FLAG('G', "Gyro", true);
PRINT_MODULE_USAGE_PARAMS_I2C_SPI_DRIVER(true, false);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x76);
PRINT_MODULE_USAGE_PARAMS_I2C_ADDRESS(0x18);
PRINT_MODULE_USAGE_PARAM_INT('R', 0, 0, 35, "Rotation", true);
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
@ -54,21 +54,24 @@ extern "C" int bmi088_i2c_main(int argc, char *argv[])
{
int ch;
using ThisDriver = BMI088;
BusCLIArguments cli{true, true};
BusCLIArguments cli{true, false};
cli.i2c_address = 0x18;
cli.default_i2c_frequency = 400 * 1000;
cli.default_spi_frequency = 400 * 1000;
uint16_t type = 0;
const char *name = MODULE_NAME;
while ((ch = cli.getOpt(argc, argv, "AGR:")) != EOF) {
switch (ch) {
case 'A':
cli.type = DRV_ACC_DEVTYPE_BMI088;
type = DRV_ACC_DEVTYPE_BMI088;
name = MODULE_NAME "_accel";
cli.i2c_address = 0x18;
break;
case 'G':
cli.type = DRV_GYR_DEVTYPE_BMI088;
type = DRV_GYR_DEVTYPE_BMI088;
name = MODULE_NAME "_gyro";
cli.i2c_address = 0x69;
break;
@ -80,12 +83,12 @@ extern "C" int bmi088_i2c_main(int argc, char *argv[])
const char *verb = cli.optArg();
if (!verb) {
if (!verb || type == 0) {
ThisDriver::print_usage();
return -1;
}
BusInstanceIterator iterator(MODULE_NAME, cli, cli.type);
BusInstanceIterator iterator(name, cli, type);
if (!strcmp(verb, "start")) {
return ThisDriver::module_start(cli, iterator);

13
src/drivers/imu/bosch/bmi088/bmi088_main.cpp
View File

@ -53,17 +53,20 @@ extern "C" int bmi088_main(int argc, char *argv[])
int ch;
using ThisDriver = BMI088;
BusCLIArguments cli{false, true};
cli.type = 0;
uint16_t type = 0;
cli.default_spi_frequency = 10000000;
const char *name = MODULE_NAME;
while ((ch = cli.getOpt(argc, argv, "AGR:")) != EOF) {
switch (ch) {
case 'A':
cli.type = DRV_ACC_DEVTYPE_BMI088;
type = DRV_ACC_DEVTYPE_BMI088;
name = MODULE_NAME "_accel";
break;
case 'G':
cli.type = DRV_GYR_DEVTYPE_BMI088;
type = DRV_GYR_DEVTYPE_BMI088;
name = MODULE_NAME "_gyro";
break;
case 'R':
@ -74,12 +77,12 @@ extern "C" int bmi088_main(int argc, char *argv[])
const char *verb = cli.optArg();
if (!verb) {
if (!verb || type == 0) {
ThisDriver::print_usage();
return -1;
}
BusInstanceIterator iterator(MODULE_NAME, cli, cli.type);
BusInstanceIterator iterator(name, cli, type);
if (!strcmp(verb, "start")) {
return ThisDriver::module_start(cli, iterator);

7
src/drivers/imu/fxas21002c/FXAS21002C.cpp
View File

@ -65,11 +65,10 @@ static constexpr uint8_t _checked_registers[] {
using namespace time_literals;
FXAS21002C::FXAS21002C(device::Device *interface, I2CSPIBusOption bus_option, int bus, enum Rotation rotation,
int i2c_address) :
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus, i2c_address),
FXAS21002C::FXAS21002C(device::Device *interface, const I2CSPIDriverConfig &config) :
I2CSPIDriver(config),
_interface(interface),
_px4_gyro(_interface->get_device_id(), rotation),
_px4_gyro(_interface->get_device_id(), config.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 register")),

5
src/drivers/imu/fxas21002c/FXAS21002C.hpp
View File

@ -191,11 +191,10 @@ struct RawGyroReport {
class FXAS21002C : public I2CSPIDriver<FXAS21002C>
{
public:
FXAS21002C(device::Device *interface, I2CSPIBusOption bus_option, int bus, enum Rotation rotation, int i2c_address);
FXAS21002C(device::Device *interface, const I2CSPIDriverConfig &config);
virtual ~FXAS21002C();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
int init();

14
src/drivers/imu/fxas21002c/fxas21002c_main.cpp
View File

@ -50,16 +50,15 @@ FXAS21002C::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *FXAS21002C::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *FXAS21002C::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
device::Device *interface = nullptr;
if (iterator.busType() == BOARD_I2C_BUS) {
interface = FXAS21002C_I2C_interface(iterator.bus(), cli.bus_frequency, cli.i2c_address);
if (config.bus_type == BOARD_I2C_BUS) {
interface = FXAS21002C_I2C_interface(config.bus, config.bus_frequency, config.i2c_address);
} else if (iterator.busType() == BOARD_SPI_BUS) {
interface = FXAS21002C_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
} else if (config.bus_type == BOARD_SPI_BUS) {
interface = FXAS21002C_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
}
if (interface == nullptr) {
@ -67,8 +66,7 @@ I2CSPIDriverBase *FXAS21002C::instantiate(const BusCLIArguments &cli, const BusI
return nullptr;
}
FXAS21002C *dev = new FXAS21002C(interface, iterator.configuredBusOption(), iterator.bus(), cli.rotation,
cli.i2c_address);
FXAS21002C *dev = new FXAS21002C(interface, config);
if (dev == nullptr) {
delete interface;

9
src/drivers/imu/fxos8701cq/FXOS8701CQ.cpp
View File

@ -53,13 +53,12 @@ const uint8_t FXOS8701CQ::_checked_registers[FXOS8701C_NUM_CHECKED_REGISTERS] =
FXOS8701CQ_M_CTRL_REG2,
};
FXOS8701CQ::FXOS8701CQ(device::Device *interface, I2CSPIBusOption bus_option, int bus, enum Rotation rotation,
int i2c_address) :
I2CSPIDriver(MODULE_NAME, px4::device_bus_to_wq(interface->get_device_id()), bus_option, bus, i2c_address),
FXOS8701CQ::FXOS8701CQ(device::Device *interface, const I2CSPIDriverConfig &config) :
I2CSPIDriver(config),
_interface(interface),
_px4_accel(interface->get_device_id(), rotation),
_px4_accel(interface->get_device_id(), config.rotation),
#if !defined(BOARD_HAS_NOISY_FXOS8700_MAG)
_px4_mag(interface->get_device_id(), rotation),
_px4_mag(interface->get_device_id(), config.rotation),
_mag_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": mag read")),
#endif
_accel_sample_perf(perf_alloc(PC_ELAPSED, MODULE_NAME": acc read")),

5
src/drivers/imu/fxos8701cq/FXOS8701CQ.hpp
View File

@ -138,11 +138,10 @@ extern device::Device *FXOS8701CQ_I2C_interface(int bus, int bus_frequency, int
class FXOS8701CQ : public I2CSPIDriver<FXOS8701CQ>
{
public:
FXOS8701CQ(device::Device *interface, I2CSPIBusOption bus_option, int bus, enum Rotation rotation, int i2c_address);
FXOS8701CQ(device::Device *interface, const I2CSPIDriverConfig &config);
virtual ~FXOS8701CQ();
static I2CSPIDriverBase *instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance);
static I2CSPIDriverBase *instantiate(const I2CSPIDriverConfig &config, int runtime_instance);
static void print_usage();
int init();

14
src/drivers/imu/fxos8701cq/fxos8701cq_main.cpp
View File

@ -56,16 +56,15 @@ FXOS8701CQ::print_usage()
PRINT_MODULE_USAGE_DEFAULT_COMMANDS();
}
I2CSPIDriverBase *FXOS8701CQ::instantiate(const BusCLIArguments &cli, const BusInstanceIterator &iterator,
int runtime_instance)
I2CSPIDriverBase *FXOS8701CQ::instantiate(const I2CSPIDriverConfig &config, int runtime_instance)
{
device::Device *interface = nullptr;
if (iterator.busType() == BOARD_I2C_BUS) {
interface = FXOS8701CQ_I2C_interface(iterator.bus(), cli.bus_frequency, cli.i2c_address);
if (config.bus_type == BOARD_I2C_BUS) {
interface = FXOS8701CQ_I2C_interface(config.bus, config.bus_frequency, config.i2c_address);
} else if (iterator.busType() == BOARD_SPI_BUS) {
interface = FXOS8701CQ_SPI_interface(iterator.bus(), iterator.devid(), cli.bus_frequency, cli.spi_mode);
} else if (config.bus_type == BOARD_SPI_BUS) {
interface = FXOS8701CQ_SPI_interface(config.bus, config.spi_devid, config.bus_frequency, config.spi_mode);
}
if (interface == nullptr) {
@ -73,8 +72,7 @@ I2CSPIDriverBase *FXOS8701CQ::instantiate(const BusCLIArguments &cli, const BusI
return nullptr;
}
FXOS8701CQ *dev = new FXOS8701CQ(interface, iterator.configuredBusOption(), iterator.bus(), cli.rotation,
cli.i2c_address);
FXOS8701CQ *dev = new FXOS8701CQ(interface, config);
if (dev == nullptr) {
delete interface;

Some files were not shown because too many files have changed in this diff Show More