Mirror/betaflight
1
0
Fork 0
mirror of https://github.com/betaflight/betaflight.git synced 2025-07-25 01:05:27 +03:00
Code Issues Wiki Activity

Baro and Mag driver check for I2C bus being busy (#13509)

Browse source 
* Baro and Mag driver check for I2C bus being busy

* Update src/main/drivers/bus_i2c_busdev.c

Co-authored-by: Petr Ledvina <ledvinap@gmail.com>

---------

Co-authored-by: Petr Ledvina <ledvinap@gmail.com>
This commit is contained in:
Steve Evans 2024-04-10 00:53:33 +01:00 • committed by GitHub
parent 5f2adf6e6f
commit 7073b0e351
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
18 changed files with 105 additions and 98 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/main/drivers/barometer/barometer.h
View file

@ -25,7 +25,7 @@
struct baroDev_s; struct baroDev_s;
typedef void (*baroOpFuncPtr)(struct baroDev_s *baro); // baro start operation typedef bool (*baroOpFuncPtr)(struct baroDev_s *baro); // baro start operation
typedef bool (*baroGetFuncPtr)(struct baroDev_s *baro); // baro read/get operation typedef bool (*baroGetFuncPtr)(struct baroDev_s *baro); // baro read/get operation
typedef void (*baroCalculateFuncPtr)(int32_t *pressure, int32_t *temperature); // baro calculation (filled params are pressure and temperature) typedef void (*baroCalculateFuncPtr)(int32_t *pressure, int32_t *temperature); // baro calculation (filled params are pressure and temperature)

12
src/main/drivers/barometer/barometer_2smpb_02b.c
View file

@ -200,10 +200,10 @@ static void busDeviceDeInit(const extDevice_t *dev)
#endif #endif
} }
static void b2smpbStartUP(baroDev_t *baro) static bool b2smpbStartUP(baroDev_t *baro)
{ {
// start a forced measurement // start a forced measurement
busWriteRegister(&baro->dev, REG_CTRL_MEAS, REG_CLT_MEAS_VAL_TAVG4X_PAVG32X_FORCED); return busWriteRegister(&baro->dev, REG_CTRL_MEAS, REG_CLT_MEAS_VAL_TAVG4X_PAVG32X_FORCED);
} }
static bool b2smpbReadUP(baroDev_t *baro) static bool b2smpbReadUP(baroDev_t *baro)
@ -213,9 +213,7 @@ static bool b2smpbReadUP(baroDev_t *baro)
} }
// Start reading temperature and pressure data // Start reading temperature and pressure data
busReadRegisterBufferStart(&baro->dev, REG_PRESS_TXD2, &baroDataBuf[0], 6); return busReadRegisterBufferStart(&baro->dev, REG_PRESS_TXD2, &baroDataBuf[0], 6);
return true;
} }
static bool b2smpbGetUP(baroDev_t *baro) static bool b2smpbGetUP(baroDev_t *baro)
@ -247,9 +245,11 @@ static bool b2smpbGetUP(baroDev_t *baro)
return true; return true;
} }
static void b2smpbStartUT(baroDev_t *baro) static bool b2smpbStartUT(baroDev_t *baro)
{ {
UNUSED(baro); UNUSED(baro);
return true;
} }
static bool b2smpbReadUT(baroDev_t *baro) static bool b2smpbReadUT(baroDev_t *baro)

20
src/main/drivers/barometer/barometer_bmp085.c
View file

@ -123,10 +123,10 @@ STATIC_UNIT_TESTED uint16_t bmp085_ut; // static result of temperature measurem
STATIC_UNIT_TESTED uint32_t bmp085_up; // static result of pressure measurement STATIC_UNIT_TESTED uint32_t bmp085_up; // static result of pressure measurement
static void bmp085ReadCalibrarionParameters(const extDevice_t *dev); static void bmp085ReadCalibrarionParameters(const extDevice_t *dev);
static void bmp085StartUT(baroDev_t *baro); static bool bmp085StartUT(baroDev_t *baro);
static bool bmp085ReadUT(baroDev_t *baro); static bool bmp085ReadUT(baroDev_t *baro);
static bool bmp085GetUT(baroDev_t *baro); static bool bmp085GetUT(baroDev_t *baro);
static void bmp085StartUP(baroDev_t *baro); static bool bmp085StartUP(baroDev_t *baro);
static bool bmp085ReadUP(baroDev_t *baro); static bool bmp085ReadUP(baroDev_t *baro);
static bool bmp085GetUP(baroDev_t *baro); static bool bmp085GetUP(baroDev_t *baro);
static int32_t bmp085GetTemperature(uint32_t ut); static int32_t bmp085GetTemperature(uint32_t ut);
@ -273,11 +273,11 @@ static int32_t bmp085GetPressure(uint32_t up)
return pressure; return pressure;
} }
static void bmp085StartUT(baroDev_t *baro) static bool bmp085StartUT(baroDev_t *baro)
{ {
isConversionComplete = false; isConversionComplete = false;
busWriteRegisterStart(&baro->dev, BMP085_CTRL_MEAS_REG, BMP085_T_MEASURE); return busWriteRegisterStart(&baro->dev, BMP085_CTRL_MEAS_REG, BMP085_T_MEASURE);
} }
static bool bmp085ReadUT(baroDev_t *baro) static bool bmp085ReadUT(baroDev_t *baro)
@ -291,9 +291,7 @@ static bool bmp085ReadUT(baroDev_t *baro)
return false; return false;
} }
busReadRegisterBufferStart(&baro->dev, BMP085_ADC_OUT_MSB_REG, sensor_data, BMP085_DATA_TEMP_SIZE); return busReadRegisterBufferStart(&baro->dev, BMP085_ADC_OUT_MSB_REG, sensor_data, BMP085_DATA_TEMP_SIZE);
return true;
} }
static bool bmp085GetUT(baroDev_t *baro) static bool bmp085GetUT(baroDev_t *baro)
@ -307,7 +305,7 @@ static bool bmp085GetUT(baroDev_t *baro)
return true; return true;
} }
static void bmp085StartUP(baroDev_t *baro) static bool bmp085StartUP(baroDev_t *baro)
{ {
uint8_t ctrl_reg_data; uint8_t ctrl_reg_data;
@ -315,7 +313,7 @@ static void bmp085StartUP(baroDev_t *baro)
isConversionComplete = false; isConversionComplete = false;
busWriteRegisterStart(&baro->dev, BMP085_CTRL_MEAS_REG, ctrl_reg_data); return busWriteRegisterStart(&baro->dev, BMP085_CTRL_MEAS_REG, ctrl_reg_data);
} }
static bool bmp085ReadUP(baroDev_t *baro) static bool bmp085ReadUP(baroDev_t *baro)
@ -329,9 +327,7 @@ static bool bmp085ReadUP(baroDev_t *baro)
return false; return false;
} }
busReadRegisterBufferStart(&baro->dev, BMP085_ADC_OUT_MSB_REG, sensor_data, BMP085_DATA_PRES_SIZE); return busReadRegisterBufferStart(&baro->dev, BMP085_ADC_OUT_MSB_REG, sensor_data, BMP085_DATA_PRES_SIZE);
return true;
} }
/** read out up for pressure conversion /** read out up for pressure conversion

16
src/main/drivers/barometer/barometer_bmp280.c
View file

@ -109,10 +109,10 @@ int32_t bmp280_up = 0;
int32_t bmp280_ut = 0; int32_t bmp280_ut = 0;
static DMA_DATA_ZERO_INIT uint8_t sensor_data[BMP280_DATA_FRAME_SIZE]; static DMA_DATA_ZERO_INIT uint8_t sensor_data[BMP280_DATA_FRAME_SIZE];
static void bmp280StartUT(baroDev_t *baro); static bool bmp280StartUT(baroDev_t *baro);
static bool bmp280ReadUT(baroDev_t *baro); static bool bmp280ReadUT(baroDev_t *baro);
static bool bmp280GetUT(baroDev_t *baro); static bool bmp280GetUT(baroDev_t *baro);
static void bmp280StartUP(baroDev_t *baro); static bool bmp280StartUP(baroDev_t *baro);
static bool bmp280ReadUP(baroDev_t *baro); static bool bmp280ReadUP(baroDev_t *baro);
static bool bmp280GetUP(baroDev_t *baro); static bool bmp280GetUP(baroDev_t *baro);
@ -194,10 +194,12 @@ bool bmp280Detect(baroDev_t *baro)
return true; return true;
} }
static void bmp280StartUT(baroDev_t *baro) static bool bmp280StartUT(baroDev_t *baro)
{ {
UNUSED(baro); UNUSED(baro);
// dummy // dummy
return true;
} }
static bool bmp280ReadUT(baroDev_t *baro) static bool bmp280ReadUT(baroDev_t *baro)
@ -214,11 +216,11 @@ static bool bmp280GetUT(baroDev_t *baro)
return true; return true;
} }
static void bmp280StartUP(baroDev_t *baro) static bool bmp280StartUP(baroDev_t *baro)
{ {
// start measurement // start measurement
// set oversampling + power mode (forced), and start sampling // set oversampling + power mode (forced), and start sampling
busWriteRegisterStart(&baro->dev, BMP280_CTRL_MEAS_REG, BMP280_MODE); return busWriteRegisterStart(&baro->dev, BMP280_CTRL_MEAS_REG, BMP280_MODE);
} }
static bool bmp280ReadUP(baroDev_t *baro) static bool bmp280ReadUP(baroDev_t *baro)
@ -228,9 +230,7 @@ static bool bmp280ReadUP(baroDev_t *baro)
} }
// read data from sensor // read data from sensor
busReadRegisterBufferStart(&baro->dev, BMP280_PRESSURE_MSB_REG, sensor_data, BMP280_DATA_FRAME_SIZE); return busReadRegisterBufferStart(&baro->dev, BMP280_PRESSURE_MSB_REG, sensor_data, BMP280_DATA_FRAME_SIZE);
return true;
} }
static bool bmp280GetUP(baroDev_t *baro) static bool bmp280GetUP(baroDev_t *baro)

19
src/main/drivers/barometer/barometer_bmp388.c
View file

@ -174,10 +174,10 @@ static uint8_t * sensor_data = sensor_data_buffer;
STATIC_UNIT_TESTED int64_t t_lin = 0; STATIC_UNIT_TESTED int64_t t_lin = 0;
static void bmp388StartUT(baroDev_t *baro); static bool bmp388StartUT(baroDev_t *baro);
static bool bmp388GetUT(baroDev_t *baro); static bool bmp388GetUT(baroDev_t *baro);
static bool bmp388ReadUT(baroDev_t *baro); static bool bmp388ReadUT(baroDev_t *baro);
static void bmp388StartUP(baroDev_t *baro); static bool bmp388StartUP(baroDev_t *baro);
static bool bmp388GetUP(baroDev_t *baro); static bool bmp388GetUP(baroDev_t *baro);
static bool bmp388ReadUP(baroDev_t *baro); static bool bmp388ReadUP(baroDev_t *baro);
@ -238,11 +238,11 @@ void bmp388BusDeinit(const extDevice_t *dev)
#endif #endif
} }
void bmp388BeginForcedMeasurement(const extDevice_t *dev) bool bmp388BeginForcedMeasurement(const extDevice_t *dev)
{ {
// enable pressure measurement, temperature measurement, set power mode and start sampling // enable pressure measurement, temperature measurement, set power mode and start sampling
uint8_t mode = BMP388_MODE_FORCED << 4 | 1 << 1 | 1 << 0; uint8_t mode = BMP388_MODE_FORCED << 4 | 1 << 1 | 1 << 0;
busWriteRegisterStart(dev, BMP388_PWR_CTRL_REG, mode); return busWriteRegisterStart(dev, BMP388_PWR_CTRL_REG, mode);
} }
bool bmp388Detect(const bmp388Config_t *config, baroDev_t *baro) bool bmp388Detect(const bmp388Config_t *config, baroDev_t *baro)
@ -328,10 +328,12 @@ bool bmp388Detect(const bmp388Config_t *config, baroDev_t *baro)
return true; return true;
} }
static void bmp388StartUT(baroDev_t *baro) static bool bmp388StartUT(baroDev_t *baro)
{ {
UNUSED(baro); UNUSED(baro);
// dummy // dummy
return true;
} }
static bool bmp388ReadUT(baroDev_t *baro) static bool bmp388ReadUT(baroDev_t *baro)
@ -348,10 +350,10 @@ static bool bmp388GetUT(baroDev_t *baro)
return true; return true;
} }
static void bmp388StartUP(baroDev_t *baro) static bool bmp388StartUP(baroDev_t *baro)
{ {
// start measurement // start measurement
bmp388BeginForcedMeasurement(&baro->dev); return bmp388BeginForcedMeasurement(&baro->dev);
} }
static bool bmp388ReadUP(baroDev_t *baro) static bool bmp388ReadUP(baroDev_t *baro)
@ -361,8 +363,7 @@ static bool bmp388ReadUP(baroDev_t *baro)
} }
// read data from sensor // read data from sensor
busReadRegisterBufferStart(&baro->dev, BMP388_DATA_0_REG, sensor_data_buffer, BMP388_DATA_FRAME_SIZE + (sensor_data - sensor_data_buffer)); return busReadRegisterBufferStart(&baro->dev, BMP388_DATA_0_REG, sensor_data_buffer, BMP388_DATA_FRAME_SIZE + (sensor_data - sensor_data_buffer));
return true;
} }
static bool bmp388GetUP(baroDev_t *baro) static bool bmp388GetUP(baroDev_t *baro)

12
src/main/drivers/barometer/barometer_dps310.c
View file

@ -255,9 +255,7 @@ static bool dps310ReadUP(baroDev_t *baro)
// 1. Kick off read // 1. Kick off read
// No need to poll for data ready as the conversion rate is 32Hz and this is sampling at 20Hz // No need to poll for data ready as the conversion rate is 32Hz and this is sampling at 20Hz
// Read PSR_B2, PSR_B1, PSR_B0, TMP_B2, TMP_B1, TMP_B0 // Read PSR_B2, PSR_B1, PSR_B0, TMP_B2, TMP_B1, TMP_B0
busReadRegisterBufferStart(&baro->dev, DPS310_REG_PSR_B2, buf, 6); return busReadRegisterBufferStart(&baro->dev, DPS310_REG_PSR_B2, buf, 6);
return true;
} }
static bool dps310GetUP(baroDev_t *baro) static bool dps310GetUP(baroDev_t *baro)
@ -334,9 +332,11 @@ static bool deviceDetect(const extDevice_t *dev)
return false; return false;
} }
static void dps310StartUT(baroDev_t *baro) static bool dps310StartUT(baroDev_t *baro)
{ {
UNUSED(baro); UNUSED(baro);
return true;
} }
static bool dps310ReadUT(baroDev_t *baro) static bool dps310ReadUT(baroDev_t *baro)
@ -353,9 +353,11 @@ static bool dps310GetUT(baroDev_t *baro)
return true; return true;
} }
static void dps310StartUP(baroDev_t *baro) static bool dps310StartUP(baroDev_t *baro)
{ {
UNUSED(baro); UNUSED(baro);
return true;
} }
static void deviceInit(const extDevice_t *dev, resourceOwner_e owner) static void deviceInit(const extDevice_t *dev, resourceOwner_e owner)

10
src/main/drivers/barometer/barometer_lps.c
View file

@ -221,12 +221,6 @@ static void lpsOff(const extDevice_t *dev)
lpsWriteCommand(dev, LPS_CTRL1, 0x00 | (0x01 << 2)); lpsWriteCommand(dev, LPS_CTRL1, 0x00 | (0x01 << 2));
} }
static void lpsNothing(baroDev_t *baro)
{
UNUSED(baro);
return;
}
static bool lpsNothingBool(baroDev_t *baro) static bool lpsNothingBool(baroDev_t *baro)
{ {
UNUSED(baro); UNUSED(baro);
@ -291,10 +285,10 @@ bool lpsDetect(baroDev_t *baro)
baro->combined_read = true; baro->combined_read = true;
baro->ut_delay = 1; baro->ut_delay = 1;
baro->up_delay = 1000000 / 24; baro->up_delay = 1000000 / 24;
baro->start_ut = lpsNothing; baro->start_ut = lpsNothingBool;
baro->get_ut = lpsNothingBool; baro->get_ut = lpsNothingBool;
baro->read_ut = lpsNothingBool; baro->read_ut = lpsNothingBool;
baro->start_up = lpsNothing; baro->start_up = lpsNothingBool;
baro->get_up = lpsRead; baro->get_up = lpsRead;
baro->read_up = lpsNothingBool; baro->read_up = lpsNothingBool;
baro->calculate = lpsCalculate; baro->calculate = lpsCalculate;

16
src/main/drivers/barometer/barometer_lps22df.c
View file

@ -218,10 +218,10 @@ static int32_t lps22df_ut = 0;
static DMA_DATA_ZERO_INIT uint8_t sensor_data[LPS22DF_DATA_FRAME_SIZE]; static DMA_DATA_ZERO_INIT uint8_t sensor_data[LPS22DF_DATA_FRAME_SIZE];
static void lps22dfStartUT(baroDev_t *baro); static bool lps22dfStartUT(baroDev_t *baro);
static bool lps22dfReadUT(baroDev_t *baro); static bool lps22dfReadUT(baroDev_t *baro);
static bool lps22dfGetUT(baroDev_t *baro); static bool lps22dfGetUT(baroDev_t *baro);
static void lps22dfStartUP(baroDev_t *baro); static bool lps22dfStartUP(baroDev_t *baro);
static bool lps22dfReadUP(baroDev_t *baro); static bool lps22dfReadUP(baroDev_t *baro);
static bool lps22dfGetUP(baroDev_t *baro); static bool lps22dfGetUP(baroDev_t *baro);
@ -306,10 +306,12 @@ bool lps22dfDetect(baroDev_t *baro)
return true; return true;
} }
static void lps22dfStartUT(baroDev_t *baro) static bool lps22dfStartUT(baroDev_t *baro)
{ {
UNUSED(baro); UNUSED(baro);
// dummy // dummy
return true;
} }
static bool lps22dfReadUT(baroDev_t *baro) static bool lps22dfReadUT(baroDev_t *baro)
@ -326,11 +328,11 @@ static bool lps22dfGetUT(baroDev_t *baro)
return true; return true;
} }
static void lps22dfStartUP(baroDev_t *baro) static bool lps22dfStartUP(baroDev_t *baro)
{ {
// start measurement // start measurement
// Trigger one-shot enable block data update to ensure LSB/MSB are coherent // Trigger one-shot enable block data update to ensure LSB/MSB are coherent
busWriteRegister(&baro->dev, LPS22DF_CTRL_REG2, LPS22DF_CTRL_REG2_ONESHOT | LPS22DF_CTRL_REG2_BDU); return busWriteRegister(&baro->dev, LPS22DF_CTRL_REG2, LPS22DF_CTRL_REG2_ONESHOT | LPS22DF_CTRL_REG2_BDU);
} }
static bool lps22dfReadUP(baroDev_t *baro) static bool lps22dfReadUP(baroDev_t *baro)
@ -340,9 +342,7 @@ static bool lps22dfReadUP(baroDev_t *baro)
} }
// Read data from sensor // Read data from sensor
busReadRegisterBufferStart(&baro->dev, LPS22DF_PRESSURE_OUT_XL, sensor_data, LPS22DF_DATA_FRAME_SIZE); return busReadRegisterBufferStart(&baro->dev, LPS22DF_PRESSURE_OUT_XL, sensor_data, LPS22DF_DATA_FRAME_SIZE);
return true;
} }
static bool lps22dfGetUP(baroDev_t *baro) static bool lps22dfGetUP(baroDev_t *baro)

8
src/main/drivers/barometer/barometer_ms5611.c
View file

@ -138,9 +138,9 @@ static void ms5611ReadAdc(const extDevice_t *dev)
busRawReadRegisterBufferStart(dev, CMD_ADC_READ, sensor_data, MS5611_DATA_FRAME_SIZE); // read ADC busRawReadRegisterBufferStart(dev, CMD_ADC_READ, sensor_data, MS5611_DATA_FRAME_SIZE); // read ADC
} }
static void ms5611StartUT(baroDev_t *baro) static bool ms5611StartUT(baroDev_t *baro)
{ {
busRawWriteRegisterStart(&baro->dev, CMD_ADC_CONV + CMD_ADC_D2 + ms5611_osr, 1); // D2 (temperature) conversion start! return busRawWriteRegisterStart(&baro->dev, CMD_ADC_CONV + CMD_ADC_D2 + ms5611_osr, 1); // D2 (temperature) conversion start!
} }
static bool ms5611ReadUT(baroDev_t *baro) static bool ms5611ReadUT(baroDev_t *baro)
@ -165,9 +165,9 @@ static bool ms5611GetUT(baroDev_t *baro)
return true; return true;
} }
static void ms5611StartUP(baroDev_t *baro) static bool ms5611StartUP(baroDev_t *baro)
{ {
busRawWriteRegisterStart(&baro->dev, CMD_ADC_CONV + CMD_ADC_D1 + ms5611_osr, 1); // D1 (pressure) conversion start! return busRawWriteRegisterStart(&baro->dev, CMD_ADC_CONV + CMD_ADC_D1 + ms5611_osr, 1); // D1 (pressure) conversion start!
} }
static bool ms5611ReadUP(baroDev_t *baro) static bool ms5611ReadUP(baroDev_t *baro)

16
src/main/drivers/barometer/barometer_qmp6988.c
View file

@ -96,10 +96,10 @@ int32_t qmp6988_up = 0;
int32_t qmp6988_ut = 0; int32_t qmp6988_ut = 0;
static DMA_DATA_ZERO_INIT uint8_t sensor_data[QMP6988_DATA_FRAME_SIZE]; static DMA_DATA_ZERO_INIT uint8_t sensor_data[QMP6988_DATA_FRAME_SIZE];
static void qmp6988StartUT(baroDev_t *baro); static bool qmp6988StartUT(baroDev_t *baro);
static bool qmp6988ReadUT(baroDev_t *baro); static bool qmp6988ReadUT(baroDev_t *baro);
static bool qmp6988GetUT(baroDev_t *baro); static bool qmp6988GetUT(baroDev_t *baro);
static void qmp6988StartUP(baroDev_t *baro); static bool qmp6988StartUP(baroDev_t *baro);
static bool qmp6988ReadUP(baroDev_t *baro); static bool qmp6988ReadUP(baroDev_t *baro);
static bool qmp6988GetUP(baroDev_t *baro); static bool qmp6988GetUP(baroDev_t *baro);
@ -279,10 +279,12 @@ bool qmp6988Detect(baroDev_t *baro)
return true; return true;
} }
static void qmp6988StartUT(baroDev_t *baro) static bool qmp6988StartUT(baroDev_t *baro)
{ {
UNUSED(baro); UNUSED(baro);
// dummy // dummy
return true;
} }
static bool qmp6988ReadUT(baroDev_t *baro) static bool qmp6988ReadUT(baroDev_t *baro)
@ -299,10 +301,10 @@ static bool qmp6988GetUT(baroDev_t *baro)
return true; return true;
} }
static void qmp6988StartUP(baroDev_t *baro) static bool qmp6988StartUP(baroDev_t *baro)
{ {
// start measurement // start measurement
busWriteRegister(&baro->dev, QMP6988_CTRL_MEAS_REG, QMP6988_PWR_SAMPLE_MODE); return busWriteRegister(&baro->dev, QMP6988_CTRL_MEAS_REG, QMP6988_PWR_SAMPLE_MODE);
} }
static bool qmp6988ReadUP(baroDev_t *baro) static bool qmp6988ReadUP(baroDev_t *baro)
@ -312,9 +314,7 @@ static bool qmp6988ReadUP(baroDev_t *baro)
} }
// read data from sensor // read data from sensor
busReadRegisterBufferStart(&baro->dev, QMP6988_PRESSURE_MSB_REG, sensor_data, QMP6988_DATA_FRAME_SIZE); return busReadRegisterBufferStart(&baro->dev, QMP6988_PRESSURE_MSB_REG, sensor_data, QMP6988_DATA_FRAME_SIZE);
return true;
} }
static bool qmp6988GetUP(baroDev_t *baro) static bool qmp6988GetUP(baroDev_t *baro)

4
src/main/drivers/barometer/barometer_virtual.c
View file

@ -35,9 +35,11 @@ static int32_t virtualPressure;
static int32_t virtualTemperature; static int32_t virtualTemperature;
static void virtualBaroStart(baroDev_t *baro) static bool virtualBaroStart(baroDev_t *baro)
{ {
UNUSED(baro); UNUSED(baro);
return true;
} }
static bool virtualBaroReadGet(baroDev_t *baro) static bool virtualBaroReadGet(baroDev_t *baro)

4
src/main/drivers/bus_i2c_busdev.c
View file

@ -41,6 +41,10 @@ bool i2cBusWriteRegisterStart(const extDevice_t *dev, uint8_t reg, uint8_t data)
// Need a static value, not on the stack // Need a static value, not on the stack
static uint8_t byte; static uint8_t byte;
if (i2cBusy(dev->bus->busType_u.i2c.device, NULL)) {
return false;
}
byte = data; byte = data;
return i2cWriteBuffer(dev->bus->busType_u.i2c.device, dev->busType_u.i2c.address, reg, sizeof(byte), &byte); return i2cWriteBuffer(dev->bus->busType_u.i2c.device, dev->busType_u.i2c.address, reg, sizeof(byte), &byte);

20
src/main/drivers/compass/compass_ak8975.c
View file

@ -135,8 +135,9 @@ static bool ak8975Read(magDev_t *mag, int16_t *magData)
switch (state) { switch (state) {
default: default:
case STATE_READ_STATUS1: case STATE_READ_STATUS1:
busReadRegisterBufferStart(dev, AK8975_MAG_REG_ST1, &status, sizeof(status)); if (busReadRegisterBufferStart(dev, AK8975_MAG_REG_ST1, &status, sizeof(status))) {
state = STATE_WAIT_STATUS1; state = STATE_WAIT_STATUS1;
}
return false; return false;
case STATE_WAIT_STATUS1: case STATE_WAIT_STATUS1:
@ -145,18 +146,21 @@ static bool ak8975Read(magDev_t *mag, int16_t *magData)
return false; return false;
} }
busReadRegisterBufferStart(dev, AK8975_MAG_REG_HXL, buf, sizeof(buf)); if (busReadRegisterBufferStart(dev, AK8975_MAG_REG_HXL, buf, sizeof(buf))) {
state = STATE_READ_STATUS2;
state = STATE_READ_STATUS2; }
return false; return false;
case STATE_READ_STATUS2: case STATE_READ_STATUS2:
busReadRegisterBufferStart(dev, AK8975_MAG_REG_ST2, &status, sizeof(status)); if (busReadRegisterBufferStart(dev, AK8975_MAG_REG_ST2, &status, sizeof(status))) {
state = STATE_WAIT_STATUS2; state = STATE_WAIT_STATUS2;
}
return false; return false;
case STATE_WAIT_STATUS2: case STATE_WAIT_STATUS2:
busWriteRegisterStart(dev, AK8975_MAG_REG_CNTL, CNTL_BIT_16_BIT | CNTL_MODE_ONCE); // start reading again if (!busWriteRegisterStart(dev, AK8975_MAG_REG_CNTL, CNTL_BIT_16_BIT | CNTL_MODE_ONCE)) { // start reading again
return false;
}
if ((status & ST2_REG_DATA_ERROR) || (status & ST2_REG_MAG_SENSOR_OVERFLOW)) { if ((status & ST2_REG_DATA_ERROR) || (status & ST2_REG_MAG_SENSOR_OVERFLOW)) {
state = STATE_READ_STATUS1; state = STATE_READ_STATUS1;

6
src/main/drivers/compass/compass_hmc5883l.c
View file

@ -207,9 +207,9 @@ static bool hmc5883lRead(magDev_t *mag, int16_t *magData)
extDevice_t *dev = &mag->dev; extDevice_t *dev = &mag->dev;
if (pendingRead) { if (pendingRead) {
busReadRegisterBufferStart(dev, HMC58X3_REG_DATA, buf, sizeof(buf)); if (busReadRegisterBufferStart(dev, HMC58X3_REG_DATA, buf, sizeof(buf))) {
pendingRead = false;
pendingRead = false; }
return false; return false;
} }

14
src/main/drivers/compass/compass_ist8310.c
View file

@ -147,9 +147,9 @@ static bool ist8310Read(magDev_t * magDev, int16_t *magData)
switch (state) { switch (state) {
default: default:
case STATE_REQUEST_DATA: case STATE_REQUEST_DATA:
busReadRegisterBufferStart(dev, IST8310_REG_DATA, buf, sizeof(buf)); if (busReadRegisterBufferStart(dev, IST8310_REG_DATA, buf, sizeof(buf))) {
state = STATE_FETCH_DATA;
state = STATE_FETCH_DATA; }
return false; return false;
case STATE_FETCH_DATA: case STATE_FETCH_DATA:
@ -159,11 +159,13 @@ static bool ist8310Read(magDev_t * magDev, int16_t *magData)
magData[Z] = (int16_t)(buf[5] << 8 | buf[4]) * LSB2FSV; magData[Z] = (int16_t)(buf[5] << 8 | buf[4]) * LSB2FSV;
// Force single measurement mode for next read // Force single measurement mode for next read
busWriteRegisterStart(dev, IST8310_REG_CNTRL1, IST8310_ODR_SINGLE); if (busWriteRegisterStart(dev, IST8310_REG_CNTRL1, IST8310_ODR_SINGLE)) {
state = STATE_REQUEST_DATA;
state = STATE_REQUEST_DATA; return true;
}
return true; return false;
} }
// TODO: do cross axis compensation // TODO: do cross axis compensation

6
src/main/drivers/compass/compass_lis2mdl.c
View file

@ -130,9 +130,9 @@ static bool lis2mdlRead(magDev_t * mag, int16_t *magData)
extDevice_t *dev = &mag->dev; extDevice_t *dev = &mag->dev;
if (pendingRead) { if (pendingRead) {
busReadRegisterBufferStart(dev, LIS2MDL_OUTX_L_REG, buf, sizeof(buf)); if (busReadRegisterBufferStart(dev, LIS2MDL_OUTX_L_REG, buf, sizeof(buf))) {
pendingRead = false;
pendingRead = false; }
return false; return false;
} }

6
src/main/drivers/compass/compass_lis3mdl.c
View file

@ -109,9 +109,9 @@ static bool lis3mdlRead(magDev_t * mag, int16_t *magData)
extDevice_t *dev = &mag->dev; extDevice_t *dev = &mag->dev;
if (pendingRead) { if (pendingRead) {
busReadRegisterBufferStart(dev, LIS3MDL_REG_OUT_X_L, buf, sizeof(buf)); if (busReadRegisterBufferStart(dev, LIS3MDL_REG_OUT_X_L, buf, sizeof(buf))) {
pendingRead = false;
pendingRead = false; }
return false; return false;
} }

12
src/main/drivers/compass/compass_qmc5883l.c
View file

@ -110,14 +110,16 @@ static bool qmc5883lRead(magDev_t *magDev, int16_t *magData)
case STATE_WAIT_DRDY: case STATE_WAIT_DRDY:
if (status & QMC5883L_REG_STATUS_DRDY) { if (status & QMC5883L_REG_STATUS_DRDY) {
// New data is available // New data is available
busReadRegisterBufferStart(dev, QMC5883L_REG_DATA_OUTPUT_X, buf, sizeof(buf)); if (busReadRegisterBufferStart(dev, QMC5883L_REG_DATA_OUTPUT_X, buf, sizeof(buf))) {
state = STATE_READ; state = STATE_READ;
}
} else if (status & QMC5883L_REG_STATUS_DOR) { } else if (status & QMC5883L_REG_STATUS_DOR) {
// Data overrun (and data not ready). Data registers may be locked, read unlock regiter (ZH) // Data overrun (and data not ready). Data registers may be locked, read unlock regiter (ZH)
busReadRegisterBufferStart(dev, QMC5883L_REG_DATA_UNLOCK, buf + sizeof(buf) - 1, 1); if (busReadRegisterBufferStart(dev, QMC5883L_REG_DATA_UNLOCK, buf + sizeof(buf) - 1, 1)) {
status = 0; // force status read next status = 0; // force status read next
}
} else { } else {
// Read status register to check for data ready // Read status register to check for data ready - status will be untouched if read fails
busReadRegisterBufferStart(dev, QMC5883L_REG_STATUS, &status, sizeof(status)); busReadRegisterBufferStart(dev, QMC5883L_REG_STATUS, &status, sizeof(status));
} }
return false; return false;