Added 2 IMU I2C drivers, SPI mode and bus speed option, fixed 1 I2C read bug, etc.

src/drivers/barometer/bmp280/BMP280_I2C.cpp

@@ -47,7 +47,7 @@
 class BMP280_I2C: public device::I2C, public bmp280::IBMP280
 {
 public:
-	BMP280_I2C(uint8_t bus, uint32_t device);
+	BMP280_I2C(uint8_t bus, uint32_t device, uint32_t bus_freq_hz);
 	virtual ~BMP280_I2C() override = default;
 
 	int init() override { return I2C::init(); }
@@ -65,14 +65,16 @@ class BMP280_I2C: public device::I2C, public bmp280::IBMP280
 	bmp280::data_s		_data{};
 };
 
-bmp280::IBMP280 *bmp280_i2c_interface(uint8_t busnum, uint32_t device)
+bmp280::IBMP280 *bmp280_i2c_interface(uint8_t busnum, uint32_t device,
+				      uint8_t bus_mode, uint32_t bus_freq_hz)
 {
-	return new BMP280_I2C(busnum, device);
+	return new BMP280_I2C(busnum, device, bus_freq_hz);
 }
 
-BMP280_I2C::BMP280_I2C(uint8_t bus, uint32_t device) :
-	I2C("BMP280_I2C", nullptr, bus, device, 100 * 1000)
+BMP280_I2C::BMP280_I2C(uint8_t bus, uint32_t device, uint32_t bus_freq_hz) :
+	I2C("BMP280_I2C", nullptr, bus, device, bus_freq_hz)
 {
+	PX4_DEBUG("BMP280_I2C: bus frequency: %i KHz", bus_freq_hz / 1000);
 }
 
 uint8_t

src/drivers/barometer/bmp280/BMP280_SPI.cpp

@@ -63,7 +63,7 @@ struct spi_calibration_s {
 class BMP280_SPI: public device::SPI, public bmp280::IBMP280
 {
 public:
-	BMP280_SPI(uint8_t bus, uint32_t device);
+	BMP280_SPI(uint8_t bus, uint32_t device, uint8_t bus_mode, uint32_t bus_freq_hz);
 	virtual ~BMP280_SPI() override = default;
 
 	int init() override { return SPI::init(); }
@@ -82,13 +82,15 @@ class BMP280_SPI: public device::SPI, public bmp280::IBMP280
 };
 
 bmp280::IBMP280 *
-bmp280_spi_interface(uint8_t busnum, uint32_t device)
+bmp280_spi_interface(uint8_t busnum, uint32_t device,
+		     uint8_t bus_mode, uint32_t bus_freq_hz)
 {
-	return new BMP280_SPI(busnum, device);
+	return new BMP280_SPI(busnum, device, bus_mode, bus_freq_hz);
 }
 
-BMP280_SPI::BMP280_SPI(uint8_t bus, uint32_t device) :
-	SPI("BMP280_SPI", nullptr, bus, device, SPIDEV_MODE3, 10 * 1000 * 1000)
+BMP280_SPI::BMP280_SPI(uint8_t bus, uint32_t device,
+		       uint8_t bus_mode, uint32_t bus_freq_hz) :
+	SPI("BMP280_SPI", nullptr, bus, device, (enum spi_mode_e)bus_mode, bus_freq_hz)
 {
 }
 

src/drivers/barometer/bmp280/bmp280.h

@@ -83,6 +83,9 @@
 #define BMP280_MT_INIT		6400	/* max measure time of initial p + t in us */
 #define BMP280_MT			2300	/* max measure time of p or t in us */
 
+#define BMP280_I2C_SPEED   100 * 1000
+#define BMP280_SPI_SPEED   10 * 1000 * 1000
+
 namespace bmp280
 {
 
@@ -157,6 +160,9 @@ class IBMP280
 
 
 /* interface factories */
-extern bmp280::IBMP280 *bmp280_spi_interface(uint8_t busnum, uint32_t device);
-extern bmp280::IBMP280 *bmp280_i2c_interface(uint8_t busnum, uint32_t device);
-typedef bmp280::IBMP280 *(*BMP280_constructor)(uint8_t, uint32_t);
+extern bmp280::IBMP280 *bmp280_spi_interface(uint8_t busnum, uint32_t device,
+		uint8_t bus_mode, uint32_t bus_freq_hz);
+extern bmp280::IBMP280 *bmp280_i2c_interface(uint8_t busnum, uint32_t device,
+		uint8_t bus_mode, uint32_t bus_freq_hz);
+typedef bmp280::IBMP280 *(*BMP280_constructor)(uint8_t busnum, uint32_t device,
+		uint8_t bus_mode, uint32_t bus_freq_hz);

src/drivers/barometer/bmp280/bmp280_main.cpp

@@ -54,20 +54,22 @@ struct bmp280_bus_option {
 	uint8_t busnum;
 	uint32_t address;
 	BMP280	*dev;
+	uint8_t bus_mode;
+	uint32_t bus_freq_hz;
 } bus_options[] = {
 #if defined(PX4_SPI_BUS_EXT) && defined(PX4_SPIDEV_EXT_BARO)
-	{ BMP280_BUS::SPI_EXTERNAL, &bmp280_spi_interface, PX4_SPI_BUS_EXT, PX4_SPIDEV_EXT_BARO, nullptr },
+	{ BMP280_BUS::SPI_EXTERNAL, &bmp280_spi_interface, PX4_SPI_BUS_EXT, PX4_SPIDEV_EXT_BARO, nullptr, 3, BMP280_SPI_SPEED },
 #endif
 #if defined(PX4_SPIDEV_BARO_BUS) && defined(PX4_SPIDEV_BARO)
-	{ BMP280_BUS::SPI_INTERNAL, &bmp280_spi_interface, PX4_SPIDEV_BARO_BUS, PX4_SPIDEV_BARO, nullptr },
+	{ BMP280_BUS::SPI_INTERNAL, &bmp280_spi_interface, PX4_SPIDEV_BARO_BUS, PX4_SPIDEV_BARO, nullptr, 3, BMP280_SPI_SPEED },
 #elif defined(PX4_SPI_BUS_SENSORS) && defined(PX4_SPIDEV_BARO)
-	{ BMP280_BUS::SPI_INTERNAL, &bmp280_spi_interface, PX4_SPI_BUS_SENSORS, PX4_SPIDEV_BARO, nullptr },
+	{ BMP280_BUS::SPI_INTERNAL, &bmp280_spi_interface, PX4_SPI_BUS_SENSORS, PX4_SPIDEV_BARO, nullptr, 3, BMP280_SPI_SPEED },
 #endif
 #if defined(PX4_I2C_BUS_ONBOARD) && defined(PX4_I2C_OBDEV_BMP280)
-	{ BMP280_BUS::I2C_INTERNAL, &bmp280_i2c_interface, PX4_I2C_BUS_ONBOARD, PX4_I2C_OBDEV_BMP280, nullptr },
+	{ BMP280_BUS::I2C_INTERNAL, &bmp280_i2c_interface, PX4_I2C_BUS_ONBOARD, PX4_I2C_OBDEV_BMP280, nullptr, 0, BMP280_I2C_SPEED },
 #endif
 #if defined(PX4_I2C_BUS_EXPANSION) && defined(PX4_I2C_OBDEV_BMP280)
-	{ BMP280_BUS::I2C_EXTERNAL, &bmp280_i2c_interface, PX4_I2C_BUS_EXPANSION, PX4_I2C_OBDEV_BMP280, nullptr },
+	{ BMP280_BUS::I2C_EXTERNAL, &bmp280_i2c_interface, PX4_I2C_BUS_EXPANSION, PX4_I2C_OBDEV_BMP280, nullptr, 0, BMP280_I2C_SPEED },
 #endif
 };
 
@@ -85,9 +87,25 @@ static struct bmp280_bus_option *find_bus(BMP280_BUS busid)
 	return nullptr;
 }
 
+static void updateBusMode(uint8_t dev_mode)
+{
+	for (bmp280_bus_option &bus_option : bus_options) {
+		//only one option will be used, so simply update all options here
+		bus_option.bus_mode = dev_mode;
+	}
+}
+
+static void updateBusSpeed(uint32_t freq_hz)
+{
+	for (bmp280_bus_option &bus_option : bus_options) {
+		//only one option will be used, so simply update all options here
+		bus_option.bus_freq_hz = freq_hz;
+	}
+}
+
 static bool start_bus(bmp280_bus_option &bus)
 {
-	bmp280::IBMP280 *interface = bus.interface_constructor(bus.busnum, bus.address);
+	bmp280::IBMP280 *interface = bus.interface_constructor(bus.busnum, bus.address, bus.bus_mode, bus.bus_freq_hz);
 
 	if ((interface == nullptr) || (interface->init() != PX4_OK)) {
 		PX4_WARN("no device on bus %u", (unsigned)bus.busid);
@@ -173,6 +191,8 @@ static int usage()
 	PX4_INFO("    -I    (i2c internal bus)");
 	PX4_INFO("    -s    (spi internal bus)");
 	PX4_INFO("    -S    (spi external bus)");
+	PX4_INFO("    -m    spi_bus_mode (0-3)");
+	PX4_INFO("    -k    bus_frequency_in_kHz");
 
 	return 0;
 }
@@ -187,7 +207,7 @@ extern "C" int bmp280_main(int argc, char *argv[])
 
 	BMP280_BUS busid = BMP280_BUS::ALL;
 
-	while ((ch = px4_getopt(argc, argv, "XISs:", &myoptind, &myoptarg)) != EOF) {
+	while ((ch = px4_getopt(argc, argv, "XISsm:k:", &myoptind, &myoptarg)) != EOF) {
 		switch (ch) {
 		case 'X':
 			busid = BMP280_BUS::I2C_EXTERNAL;
@@ -205,6 +225,18 @@ extern "C" int bmp280_main(int argc, char *argv[])
 			busid = BMP280_BUS::SPI_INTERNAL;
 			break;
 
+		case 'm': {
+				uint8_t bus_mode = (uint8_t)atoi(myoptarg);
+				bmp280::updateBusMode(bus_mode);
+				break;
+			}
+
+		case 'k': {
+				uint32_t bus_freq_hz = (uint32_t)atoi(myoptarg) * 1000;
+				bmp280::updateBusSpeed(bus_freq_hz);
+				break;
+			}
+
 		default:
 			return bmp280::usage();
 		}

src/drivers/distance_sensor/mappydot/MappyDot.cpp

@@ -177,7 +177,7 @@ class MappyDot : public device::I2C, public ModuleParams, public px4::ScheduledW
 	/**
 	 * Sends an i2c measure command to check for presence of a sensor.
 	 */
-	int probe();
+	int probe() override;
 
 	/**
 	 * Collects the most recent sensor measurement data from the i2c bus.
@@ -197,7 +197,7 @@ class MappyDot : public device::I2C, public ModuleParams, public px4::ScheduledW
 	px4::Array<uint8_t, RANGE_FINDER_MAX_SENSORS> _sensor_addresses {};
 	px4::Array<uint8_t, RANGE_FINDER_MAX_SENSORS> _sensor_rotations {};
 
-	size_t _sensor_count{0};
+	int _sensor_count{0};
 
 	orb_advert_t _distance_sensor_topic{nullptr};
 
@@ -250,7 +250,7 @@ MappyDot::collect()
 	perf_begin(_sample_perf);
 
 	// Increment the sensor index, (limited to the number of sensors connected).
-	for (size_t index = 0; index < _sensor_count; index++) {
+	for (int index = 0; index < _sensor_count; index++) {
 
 		// Set address of the current sensor to collect data from.
 		set_device_address(_sensor_addresses[index]);
@@ -337,7 +337,7 @@ MappyDot::init()
 
 	// Check for connected rangefinders on each i2c port,
 	// starting from the base address 0x08 and incrementing
-	for (size_t i = 0; i <= RANGE_FINDER_MAX_SENSORS; i++) {
+	for (int i = 0; i <= RANGE_FINDER_MAX_SENSORS; i++) {
 		set_device_address(MAPPYDOT_BASE_ADDR + i);
 
 		// Check if a sensor is present.
@@ -384,7 +384,6 @@ MappyDot::init()
 	}
 
 	PX4_INFO("%i sensors connected", _sensor_count);
-
 	return PX4_OK;
 }
 

src/drivers/distance_sensor/mb12xx/mb12xx.cpp

@@ -150,11 +150,10 @@ class MB12XX : public device::I2C, public ModuleParams, public px4::ScheduledWor
 	px4::Array<uint8_t, RANGE_FINDER_MAX_SENSORS> _sensor_rotations {};
 
 	int _measure_interval{MB12XX_MEASURE_INTERVAL};	// Initialize the measure interval for a single sensor.
-	int _orb_class_instance{-1};
 
-	size_t _sensor_index{0};	// Initialize counter for cycling i2c adresses to zero.
+	int _sensor_index{0};	// Initialize counter for cycling i2c adresses to zero.
 
-	size_t _sensor_count{0};
+	int _sensor_count{0};
 
 	orb_advert_t _distance_sensor_topic{nullptr};
 
@@ -350,8 +349,8 @@ MB12XX::print_info()
 	perf_print_counter(_comms_error);
 	PX4_INFO("poll interval:  %ums", _measure_interval / 1000);
 
-	for (size_t i = 0; i < _sensor_count; i++) {
-		PX4_INFO("sensor: %u, address %u", i, _sensor_addresses[i]);
+	for (int i = 0; i < _sensor_count; i++) {
+		PX4_INFO("sensor: %i, address %u", i, _sensor_addresses[i]);
 	}
 }
 

src/drivers/distance_sensor/ulanding_radar/AerotennaULanding.hpp

@@ -113,9 +113,6 @@ class AerotennaULanding : public px4::ScheduledWorkItem
 
 	int _file_descriptor{-1};
 
-	unsigned int _head{0};
-	unsigned int _tail{0};
-
 	uint8_t _buffer[ULANDING_BUFFER_LENGTH] {};
 
 	perf_counter_t _comms_errors{perf_alloc(PC_COUNT, MODULE_NAME": com_err")};

src/drivers/distance_sensor/vl53lxx/vl53lxx.cpp

@@ -101,7 +101,7 @@ class VL53LXX : public device::I2C, public px4::ScheduledWorkItem
 	 */
 	void print_info();
 
-	virtual ssize_t read(device::file_t *file_pointer, char *buffer, size_t buflen);
+	ssize_t read(device::file_t *file_pointer, char *buffer, size_t buflen) override;
 
 	/**
 	 * Initialise the automatic measurement state machine and start it.

src/drivers/imu/adis16477/ADIS16477.cpp

@@ -247,13 +247,13 @@ ADIS16477::read_reg16(uint8_t reg)
 	return cmd[0];
 }
 
-void
+int
 ADIS16477::write_reg(uint8_t reg, uint8_t val)
 {
 	uint8_t cmd[2] {};
 	cmd[0] = reg | 0x8;
 	cmd[1] = val;
-	transfer(cmd, cmd, sizeof(cmd));
+	return transfer(cmd, cmd, sizeof(cmd));
 }
 
 void

src/drivers/imu/adis16477/ADIS16477.hpp

@@ -114,7 +114,7 @@ class ADIS16477 : public device::SPI, public px4::ScheduledWorkItem
 
 	uint16_t		read_reg16(uint8_t reg);
 
-	void			write_reg(uint8_t reg, uint8_t value);
+	int			write_reg(uint8_t reg, uint8_t value);
 	void			write_reg16(uint8_t reg, uint16_t value);
 
 	// ADIS16477 onboard self test

src/drivers/imu/bmi055/BMI055.hpp

@@ -69,16 +69,17 @@ class BMI055 : public device::SPI
 	* @param       The register to read.
 	* @return      The value that was read.
 	*/
-	uint8_t         read_reg(unsigned reg);
+	uint8_t         read_reg(unsigned reg) override;
 	uint16_t        read_reg16(unsigned reg);
 
 	/**
 	* Write a register in the BMI055
 	*
 	* @param reg       The register to write.
 	* @param value     The new value to write.
+	* @return	   OK on success, negative errno otherwise.
 	*/
-	void            write_reg(unsigned reg, uint8_t value);
+	int            write_reg(unsigned reg, uint8_t value) override;
 
 	/* do not allow to copy this class due to pointer data members */
 	BMI055(const BMI055 &);

src/drivers/imu/bmi055/bmi055_main.cpp

@@ -322,15 +322,15 @@ BMI055::read_reg16(unsigned reg)
 	return (uint16_t)(cmd[1] << 8) | cmd[2];
 }
 
-void
+int
 BMI055::write_reg(unsigned reg, uint8_t value)
 {
 	uint8_t cmd[2];
 
 	cmd[0] = reg | DIR_WRITE;
 	cmd[1] = value;
 
-	transfer(cmd, nullptr, sizeof(cmd));
+	return transfer(cmd, nullptr, sizeof(cmd));
 }
 
 int

src/drivers/imu/bmi088/BMI088.hpp

@@ -70,16 +70,17 @@ class BMI088 : public device::SPI
 	* @param       The register to read.
 	* @return      The value that was read.
 	*/
-	virtual uint8_t         read_reg(unsigned reg); // This needs to be declared as virtual, because the
+	uint8_t         read_reg(unsigned reg) override;
 	virtual uint16_t        read_reg16(unsigned reg);
 
 	/**
 	* Write a register in the BMI088
 	*
 	* @param reg       The register to write.
 	* @param value     The new value to write.
+	* @return	   OK on success, negative errno otherwise.
 	*/
-	void            write_reg(unsigned reg, uint8_t value);
+	int            write_reg(unsigned reg, uint8_t value) override;
 
 	/* do not allow to copy this class due to pointer data members */
 	BMI088(const BMI088 &);

src/drivers/imu/bmi088/BMI088_accel.cpp

@@ -52,8 +52,9 @@ const uint8_t BMI088_accel::_checked_registers[BMI088_ACCEL_NUM_CHECKED_REGISTER
 										      BMI088_ACC_PWR_CTRL,
 										     };
 
-BMI088_accel::BMI088_accel(int bus, const char *path_accel, uint32_t device, enum Rotation rotation) :
-	BMI088("BMI088_ACCEL", path_accel, bus, device, SPIDEV_MODE3, BMI088_BUS_SPEED, rotation),
+BMI088_accel::BMI088_accel(int bus, const char *path_accel, uint32_t device, enum Rotation rotation,
+			   enum spi_mode_e spi_mode, uint32_t bus_freq_hz) :
+	BMI088("BMI088_ACCEL", path_accel, bus, device, spi_mode, bus_freq_hz, rotation), // both Mode 0 & 3 worked for BMI088
 	ScheduledWorkItem(MODULE_NAME, px4::device_bus_to_wq(get_device_id())),
 	_px4_accel(get_device_id(), (external() ? ORB_PRIO_MAX - 1 : ORB_PRIO_HIGH - 1), rotation),
 	_sample_perf(perf_alloc(PC_ELAPSED, "bmi088_accel_read")),
@@ -123,7 +124,7 @@ int BMI088_accel::reset()
 	 * Setting it to 5ms.
 	 */
 
-	up_udelay(5000);
+	px4_usleep(5000);
 
 	// Perform a dummy read here to put the accelerometer part of the BMI088 back into SPI mode after the reset
 	// The dummy read basically pulls the chip select line low and then high
@@ -137,7 +138,7 @@ int BMI088_accel::reset()
 	 * Any communication with the sensor during this time should be avoided
 	 * (see section "Power Modes: Acceleromter" in the BMI datasheet) */
 
-	up_udelay(5000);
+	px4_usleep(5000);
 
 	// Set the PWR CONF to be active
 	write_checked_reg(BMI088_ACC_PWR_CONF, BMI088_ACC_PWR_CONF_ACTIVE); // Sets the accelerometer to active mode