rusefi
/
atbetaflight
mirror of https://github.com/rusefi/atbetaflight.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3413 from martinbudden/bf_gyro_spi_tidy 

SPI tidy. Rename SPI functions. Rationalise parameter order.
This commit is contained in:
Martin Budden 2017-07-20 19:31:57 +01:00 committed by GitHub
parent 665aaf58cf 2fd20c2bd9
commit cf9d20bede
26 changed files with 249 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -682,6 +682,7 @@ COMMON_SRC = \
config/config_streamer.c \
drivers/adc.c \
drivers/buf_writer.c \
drivers/bus.c \
drivers/bus_i2c_busdev.c \
drivers/bus_i2c_config.c \
drivers/bus_i2c_soft.c \
@ -849,6 +850,7 @@ SPEED_OPTIMISED_SRC := $(SPEED_OPTIMISED_SRC) \
common/typeconversion.c \
drivers/adc.c \
drivers/buf_writer.c \
drivers/bus.c \
drivers/bus_i2c_busdev.c \
drivers/bus_spi.c \
drivers/exti.c \

40
src/main/drivers/accgyro/accgyro_mpu.c
View File

@ -80,7 +80,7 @@ static void mpu6050FindRevision(gyroDev_t *gyro)
// See https://android.googlesource.com/kernel/msm.git/+/eaf36994a3992b8f918c18e4f7411e8b2320a35f/drivers/misc/mpu6050/mldl_cfg.c
// determine product ID and accel revision
ack = gyro->mpuConfiguration.readFn(&gyro->bus, MPU_RA_XA_OFFS_H, 6, readBuffer);
ack = gyro->mpuConfiguration.readFn(&gyro->bus, MPU_RA_XA_OFFS_H, readBuffer, 6);
revision = ((readBuffer[5] & 0x01) << 2) | ((readBuffer[3] & 0x01) << 1) | (readBuffer[1] & 0x01);
if (revision) {
/* Congrats, these parts are better. */
@ -94,7 +94,7 @@ static void mpu6050FindRevision(gyroDev_t *gyro)
failureMode(FAILURE_ACC_INCOMPATIBLE);
}
} else {
ack = gyro->mpuConfiguration.readFn(&gyro->bus, MPU_RA_PRODUCT_ID, 1, &productId);
ack = gyro->mpuConfiguration.readFn(&gyro->bus, MPU_RA_PRODUCT_ID, &productId, 1);
revision = productId & 0x0F;
if (!revision) {
failureMode(FAILURE_ACC_INCOMPATIBLE);
@ -165,14 +165,14 @@ static void mpuIntExtiInit(gyroDev_t *gyro)
#endif
}
bool mpuReadRegisterI2C(const busDevice_t *bus, uint8_t reg, uint8_t length, uint8_t* data)
static bool mpuReadRegisterI2C(const busDevice_t *bus, uint8_t reg, uint8_t* data, uint8_t length)
{
UNUSED(bus);
const bool ack = i2cRead(MPU_I2C_INSTANCE, MPU_ADDRESS, reg, length, data);
return ack;
}
bool mpuWriteRegisterI2C(const busDevice_t *bus, uint8_t reg, uint8_t data)
static bool mpuWriteRegisterI2C(const busDevice_t *bus, uint8_t reg, uint8_t data)
{
UNUSED(bus);
const bool ack = i2cWrite(MPU_I2C_INSTANCE, MPU_ADDRESS, reg, data);
@ -183,7 +183,7 @@ bool mpuAccRead(accDev_t *acc)
{
uint8_t data[6];
const bool ack = acc->mpuConfiguration.readFn(&acc->bus, MPU_RA_ACCEL_XOUT_H, 6, data);
const bool ack = acc->mpuConfiguration.readFn(&acc->bus, MPU_RA_ACCEL_XOUT_H, data, 6);
if (!ack) {
return false;
}
@ -206,7 +206,7 @@ bool mpuGyroRead(gyroDev_t *gyro)
{
uint8_t data[6];
const bool ack = gyro->mpuConfiguration.readFn(&gyro->bus, MPU_RA_GYRO_XOUT_H, 6, data);
const bool ack = gyro->mpuConfiguration.readFn(&gyro->bus, MPU_RA_GYRO_XOUT_H, data, 6);
if (!ack) {
return false;
}
@ -223,7 +223,7 @@ bool mpuGyroReadSPI(gyroDev_t *gyro)
static const uint8_t dataToSend[7] = {MPU_RA_GYRO_XOUT_H | 0x80, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t data[7];
const bool ack = spiBusTransfer(&gyro->bus, data, dataToSend, 7);
const bool ack = spiBusTransfer(&gyro->bus, dataToSend, data, 7);
if (!ack) {
return false;
}
@ -253,8 +253,8 @@ static bool detectSPISensorsAndUpdateDetectionResult(gyroDev_t *gyro)
sensor = mpu6000SpiDetect(&gyro->bus);
if (sensor != MPU_NONE) {
gyro->mpuDetectionResult.sensor = sensor;
gyro->mpuConfiguration.readFn = spiReadRegisterBuffer;
gyro->mpuConfiguration.writeFn = spiWriteRegister;
gyro->mpuConfiguration.readFn = spiBusReadRegisterBuffer;
gyro->mpuConfiguration.writeFn = spiBusWriteRegister;
return true;
}
#endif
@ -270,8 +270,8 @@ static bool detectSPISensorsAndUpdateDetectionResult(gyroDev_t *gyro)
// some targets using MPU_9250_SPI, ICM_20608_SPI or ICM_20602_SPI state sensor is MPU_65xx_SPI
if (sensor != MPU_NONE) {
gyro->mpuDetectionResult.sensor = sensor;
gyro->mpuConfiguration.readFn = spiReadRegisterBuffer;
gyro->mpuConfiguration.writeFn = spiWriteRegister;
gyro->mpuConfiguration.readFn = spiBusReadRegisterBuffer;
gyro->mpuConfiguration.writeFn = spiBusWriteRegister;
return true;
}
#endif
@ -286,8 +286,8 @@ static bool detectSPISensorsAndUpdateDetectionResult(gyroDev_t *gyro)
sensor = mpu9250SpiDetect(&gyro->bus);
if (sensor != MPU_NONE) {
gyro->mpuDetectionResult.sensor = sensor;
gyro->mpuConfiguration.readFn = spiReadRegisterBuffer;
gyro->mpuConfiguration.writeFn = spiWriteRegister;
gyro->mpuConfiguration.readFn = spiBusReadRegisterBuffer;
gyro->mpuConfiguration.writeFn = spiBusWriteRegister;
gyro->mpuConfiguration.resetFn = mpu9250SpiResetGyro;
return true;
}
@ -303,8 +303,8 @@ static bool detectSPISensorsAndUpdateDetectionResult(gyroDev_t *gyro)
sensor = icm20689SpiDetect(&gyro->bus);
if (sensor != MPU_NONE) {
gyro->mpuDetectionResult.sensor = sensor;
gyro->mpuConfiguration.readFn = spiReadRegisterBuffer;
gyro->mpuConfiguration.writeFn = spiWriteRegister;
gyro->mpuConfiguration.readFn = spiBusReadRegisterBuffer;
gyro->mpuConfiguration.writeFn = spiBusWriteRegister;
return true;
}
#endif
@ -319,8 +319,8 @@ static bool detectSPISensorsAndUpdateDetectionResult(gyroDev_t *gyro)
sensor = bmi160Detect(&gyro->bus);
if (sensor != MPU_NONE) {
gyro->mpuDetectionResult.sensor = sensor;
gyro->mpuConfiguration.readFn = spiReadRegisterBuffer;
gyro->mpuConfiguration.writeFn = spiWriteRegister;
gyro->mpuConfiguration.readFn = spiBusReadRegisterBuffer;
gyro->mpuConfiguration.writeFn = spiBusWriteRegister;
return true;
}
#endif
@ -336,7 +336,9 @@ void mpuDetect(gyroDev_t *gyro)
uint8_t sig = 0;
#ifdef USE_I2C
bool ack = mpuReadRegisterI2C(&gyro->bus, MPU_RA_WHO_AM_I, 1, &sig);
gyro->bus.busdev_u.i2c.device = MPU_I2C_INSTANCE;
gyro->bus.busdev_u.i2c.address = MPU_ADDRESS;
bool ack = mpuReadRegisterI2C(&gyro->bus, MPU_RA_WHO_AM_I, &sig, 1);
#else
bool ack = false;
#endif
@ -352,7 +354,7 @@ void mpuDetect(gyroDev_t *gyro)
// If an MPU3050 is connected sig will contain 0.
uint8_t inquiryResult;
ack = mpuReadRegisterI2C(&gyro->bus, MPU_RA_WHO_AM_I_LEGACY, 1, &inquiryResult);
ack = mpuReadRegisterI2C(&gyro->bus, MPU_RA_WHO_AM_I_LEGACY, &inquiryResult, 1);
inquiryResult &= MPU_INQUIRY_MASK;
if (ack && inquiryResult == MPUx0x0_WHO_AM_I_CONST) {
gyro->mpuDetectionResult.sensor = MPU_3050;

5
src/main/drivers/accgyro/accgyro_mpu.h
View File

@ -125,7 +125,7 @@
// RF = Register Flag
#define MPU_RF_DATA_RDY_EN (1 << 0)
typedef bool (*mpuReadRegisterFnPtr)(const busDevice_t *bus, uint8_t reg, uint8_t length, uint8_t* data);
typedef bool (*mpuReadRegisterFnPtr)(const busDevice_t *bus, uint8_t reg, uint8_t* data, uint8_t length);
typedef bool (*mpuWriteRegisterFnPtr)(const busDevice_t *bus, uint8_t reg, uint8_t data);
typedef void (*mpuResetFnPtr)(void);
@ -190,9 +190,6 @@ typedef struct mpuDetectionResult_s {
mpu6050Resolution_e resolution;
} mpuDetectionResult_t;
bool mpuReadRegisterI2C(const busDevice_t *bus, uint8_t reg, uint8_t length, uint8_t* data);
bool mpuWriteRegisterI2C(const busDevice_t *bus, uint8_t reg, uint8_t data);
struct gyroDev_s;
void mpuGyroInit(struct gyroDev_s *gyro);
struct accDev_s;

4
src/main/drivers/accgyro/accgyro_mpu3050.c
View File

@ -68,7 +68,7 @@ static bool mpu3050GyroRead(gyroDev_t *gyro)
{
uint8_t data[6];
const bool ack = gyro->mpuConfiguration.readFn(&gyro->bus, MPU3050_GYRO_OUT, 6, data);
const bool ack = gyro->mpuConfiguration.readFn(&gyro->bus, MPU3050_GYRO_OUT, data, 6);
if (!ack) {
return false;
}
@ -83,7 +83,7 @@ static bool mpu3050GyroRead(gyroDev_t *gyro)
static bool mpu3050ReadTemperature(gyroDev_t *gyro, int16_t *tempData)
{
uint8_t buf[2];
if (!gyro->mpuConfiguration.readFn(&gyro->bus, MPU3050_TEMP_OUT, 2, buf)) {
if (!gyro->mpuConfiguration.readFn(&gyro->bus, MPU3050_TEMP_OUT, buf, 2)) {
return false;
}

38
src/main/drivers/accgyro/accgyro_spi_bmi160.c
View File

@ -104,12 +104,12 @@ uint8_t bmi160Detect(const busDevice_t *bus)
spiSetDivisor(bus->busdev_u.spi.instance, BMI160_SPI_DIVISOR);
/* Read this address to acticate SPI (see p. 84) */
spiReadRegister(bus, 0x7F);
/* Read this address to activate SPI (see p. 84) */
spiBusReadRegister(bus, 0x7F);
delay(10); // Give SPI some time to start up
/* Check the chip ID */
if (spiReadRegister(bus, BMI160_REG_CHIPID) != 0xd1) {
if (spiBusReadRegister(bus, BMI160_REG_CHIPID) != 0xd1) {
return MPU_NONE;
}
@ -162,7 +162,7 @@ static int32_t BMI160_Config(const busDevice_t *bus)
delay(5); // can take up to 3.8ms
// Verify that normal power mode was entered
uint8_t pmu_status = spiReadRegister(bus, BMI160_REG_PMU_STAT);
uint8_t pmu_status = spiBusReadRegister(bus, BMI160_REG_PMU_STAT);
if ((pmu_status & 0x3C) != 0x14){
return -3;
}
@ -191,7 +191,7 @@ static int32_t BMI160_Config(const busDevice_t *bus)
delay(1);
// Enable offset compensation
uint8_t val = spiReadRegister(bus, BMI160_REG_OFFSET_0);
uint8_t val = spiBusReadRegister(bus, BMI160_REG_OFFSET_0);
if (BMI160_WriteReg(bus, BMI160_REG_OFFSET_0, val | 0xC0) != 0) {
return -7;
}
@ -232,7 +232,7 @@ static int32_t BMI160_do_foc(const busDevice_t *bus)
// Wait for FOC to complete
for (int i=0; i<50; i++) {
val = spiReadRegister(bus, BMI160_REG_STATUS);
val = spiBusReadRegister(bus, BMI160_REG_STATUS);
if (val & BMI160_REG_STATUS_FOC_RDY) {
break;
}
@ -243,7 +243,7 @@ static int32_t BMI160_do_foc(const busDevice_t *bus)
}
// Program NVM
val = spiReadRegister(bus, BMI160_REG_CONF);
val = spiBusReadRegister(bus, BMI160_REG_CONF);
if (BMI160_WriteReg(bus, BMI160_REG_CONF, val | BMI160_REG_CONF_NVM_PROG_EN) != 0) {
return -4;
}
@ -254,7 +254,7 @@ static int32_t BMI160_do_foc(const busDevice_t *bus)
// Wait for NVM programming to complete
for (int i=0; i<50; i++) {
val = spiReadRegister(bus, BMI160_REG_STATUS);
val = spiBusReadRegister(bus, BMI160_REG_STATUS);
if (val & BMI160_REG_STATUS_NVM_RDY) {
break;
}
@ -321,16 +321,16 @@ bool bmi160AccRead(accDev_t *acc)
BUFFER_SIZE,
};
uint8_t bmi160_rec_buf[BUFFER_SIZE];
uint8_t bmi160_tx_buf[BUFFER_SIZE] = {BMI160_REG_ACC_DATA_X_LSB | 0x80, 0, 0, 0, 0, 0, 0};
uint8_t bmi160_rx_buf[BUFFER_SIZE];
static const uint8_t bmi160_tx_buf[BUFFER_SIZE] = {BMI160_REG_ACC_DATA_X_LSB | 0x80, 0, 0, 0, 0, 0, 0};
IOLo(acc->bus.busdev_u.spi.csnPin);
spiTransfer(acc->bus.busdev_u.spi.instance, bmi160_rec_buf, bmi160_tx_buf, BUFFER_SIZE); // receive response
spiTransfer(acc->bus.busdev_u.spi.instance, bmi160_tx_buf, bmi160_rx_buf, BUFFER_SIZE); // receive response
IOHi(acc->bus.busdev_u.spi.csnPin);
acc->ADCRaw[X] = (int16_t)((bmi160_rec_buf[IDX_ACCEL_XOUT_H] << 8) | bmi160_rec_buf[IDX_ACCEL_XOUT_L]);
acc->ADCRaw[Y] = (int16_t)((bmi160_rec_buf[IDX_ACCEL_YOUT_H] << 8) | bmi160_rec_buf[IDX_ACCEL_YOUT_L]);
acc->ADCRaw[Z] = (int16_t)((bmi160_rec_buf[IDX_ACCEL_ZOUT_H] << 8) | bmi160_rec_buf[IDX_ACCEL_ZOUT_L]);
acc->ADCRaw[X] = (int16_t)((bmi160_rx_buf[IDX_ACCEL_XOUT_H] << 8) | bmi160_rx_buf[IDX_ACCEL_XOUT_L]);
acc->ADCRaw[Y] = (int16_t)((bmi160_rx_buf[IDX_ACCEL_YOUT_H] << 8) | bmi160_rx_buf[IDX_ACCEL_YOUT_L]);
acc->ADCRaw[Z] = (int16_t)((bmi160_rx_buf[IDX_ACCEL_ZOUT_H] << 8) | bmi160_rx_buf[IDX_ACCEL_ZOUT_L]);
return true;
}
@ -349,16 +349,16 @@ bool bmi160GyroRead(gyroDev_t *gyro)
BUFFER_SIZE,
};
uint8_t bmi160_rec_buf[BUFFER_SIZE];
uint8_t bmi160_rx_buf[BUFFER_SIZE];
static const uint8_t bmi160_tx_buf[BUFFER_SIZE] = {BMI160_REG_GYR_DATA_X_LSB | 0x80, 0, 0, 0, 0, 0, 0};
IOLo(gyro->bus.busdev_u.spi.csnPin);
spiTransfer(gyro->bus.busdev_u.spi.instance, bmi160_rec_buf, bmi160_tx_buf, BUFFER_SIZE); // receive response
spiTransfer(gyro->bus.busdev_u.spi.instance, bmi160_tx_buf, bmi160_rx_buf, BUFFER_SIZE); // receive response
IOHi(gyro->bus.busdev_u.spi.csnPin);
gyro->gyroADCRaw[X] = (int16_t)((bmi160_rec_buf[IDX_GYRO_XOUT_H] << 8) | bmi160_rec_buf[IDX_GYRO_XOUT_L]);
gyro->gyroADCRaw[Y] = (int16_t)((bmi160_rec_buf[IDX_GYRO_YOUT_H] << 8) | bmi160_rec_buf[IDX_GYRO_YOUT_L]);
gyro->gyroADCRaw[Z] = (int16_t)((bmi160_rec_buf[IDX_GYRO_ZOUT_H] << 8) | bmi160_rec_buf[IDX_GYRO_ZOUT_L]);
gyro->gyroADCRaw[X] = (int16_t)((bmi160_rx_buf[IDX_GYRO_XOUT_H] << 8) | bmi160_rx_buf[IDX_GYRO_XOUT_L]);
gyro->gyroADCRaw[Y] = (int16_t)((bmi160_rx_buf[IDX_GYRO_YOUT_H] << 8) | bmi160_rx_buf[IDX_GYRO_YOUT_L]);
gyro->gyroADCRaw[Z] = (int16_t)((bmi160_rx_buf[IDX_GYRO_ZOUT_H] << 8) | bmi160_rx_buf[IDX_GYRO_ZOUT_L]);
return true;
}

4
src/main/drivers/accgyro/accgyro_spi_icm20689.c
View File

@ -59,12 +59,12 @@ uint8_t icm20689SpiDetect(const busDevice_t *bus)
spiSetDivisor(bus->busdev_u.spi.instance, SPI_CLOCK_INITIALIZATON); //low speed
spiWriteRegister(bus, MPU_RA_PWR_MGMT_1, ICM20689_BIT_RESET);
spiBusWriteRegister(bus, MPU_RA_PWR_MGMT_1, ICM20689_BIT_RESET);
uint8_t attemptsRemaining = 20;
do {
delay(150);
const uint8_t whoAmI = spiReadRegister(bus, MPU_RA_WHO_AM_I);
const uint8_t whoAmI = spiBusReadRegister(bus, MPU_RA_WHO_AM_I);
if (whoAmI == ICM20689_WHO_AM_I_CONST) {
break;
}

28
src/main/drivers/accgyro/accgyro_spi_mpu6000.c
View File

@ -108,7 +108,7 @@ void mpu6000SpiGyroInit(gyroDev_t *gyro)
spiSetDivisor(gyro->bus.busdev_u.spi.instance, SPI_CLOCK_INITIALIZATON);
// Accel and Gyro DLPF Setting
spiWriteRegister(&gyro->bus, MPU6000_CONFIG, gyro->lpf);
spiBusWriteRegister(&gyro->bus, MPU6000_CONFIG, gyro->lpf);
delayMicroseconds(1);
spiSetDivisor(gyro->bus.busdev_u.spi.instance, SPI_CLOCK_FAST); // 18 MHz SPI clock
@ -133,13 +133,13 @@ uint8_t mpu6000SpiDetect(const busDevice_t *bus)
spiSetDivisor(bus->busdev_u.spi.instance, SPI_CLOCK_INITIALIZATON);
spiWriteRegister(bus, MPU_RA_PWR_MGMT_1, BIT_H_RESET);
spiBusWriteRegister(bus, MPU_RA_PWR_MGMT_1, BIT_H_RESET);
uint8_t attemptsRemaining = 5;
do {
delay(150);
const uint8_t whoAmI = spiReadRegister(bus, MPU_RA_WHO_AM_I);
const uint8_t whoAmI = spiBusReadRegister(bus, MPU_RA_WHO_AM_I);
if (whoAmI == MPU6000_WHO_AM_I_CONST) {
break;
}
@ -148,7 +148,7 @@ uint8_t mpu6000SpiDetect(const busDevice_t *bus)
}
} while (attemptsRemaining--);
const uint8_t productID = spiReadRegister(bus, MPU_RA_PRODUCT_ID);
const uint8_t productID = spiBusReadRegister(bus, MPU_RA_PRODUCT_ID);
/* look for a product ID we recognise */
@ -181,41 +181,41 @@ static void mpu6000AccAndGyroInit(gyroDev_t *gyro)
spiSetDivisor(gyro->bus.busdev_u.spi.instance, SPI_CLOCK_INITIALIZATON);
// Device Reset
spiWriteRegister(&gyro->bus, MPU_RA_PWR_MGMT_1, BIT_H_RESET);
spiBusWriteRegister(&gyro->bus, MPU_RA_PWR_MGMT_1, BIT_H_RESET);
delay(150);
spiWriteRegister(&gyro->bus, MPU_RA_SIGNAL_PATH_RESET, BIT_GYRO | BIT_ACC | BIT_TEMP);
spiBusWriteRegister(&gyro->bus, MPU_RA_SIGNAL_PATH_RESET, BIT_GYRO | BIT_ACC | BIT_TEMP);
delay(150);
// Clock Source PPL with Z axis gyro reference
spiWriteRegister(&gyro->bus, MPU_RA_PWR_MGMT_1, MPU_CLK_SEL_PLLGYROZ);
spiBusWriteRegister(&gyro->bus, MPU_RA_PWR_MGMT_1, MPU_CLK_SEL_PLLGYROZ);
delayMicroseconds(15);
// Disable Primary I2C Interface
spiWriteRegister(&gyro->bus, MPU_RA_USER_CTRL, BIT_I2C_IF_DIS);
spiBusWriteRegister(&gyro->bus, MPU_RA_USER_CTRL, BIT_I2C_IF_DIS);
delayMicroseconds(15);
spiWriteRegister(&gyro->bus, MPU_RA_PWR_MGMT_2, 0x00);
spiBusWriteRegister(&gyro->bus, MPU_RA_PWR_MGMT_2, 0x00);
delayMicroseconds(15);
// Accel Sample Rate 1kHz
// Gyroscope Output Rate = 1kHz when the DLPF is enabled
spiWriteRegister(&gyro->bus, MPU_RA_SMPLRT_DIV, gyroMPU6xxxGetDividerDrops(gyro));
spiBusWriteRegister(&gyro->bus, MPU_RA_SMPLRT_DIV, gyroMPU6xxxGetDividerDrops(gyro));
delayMicroseconds(15);
// Gyro +/- 1000 DPS Full Scale
spiWriteRegister(&gyro->bus, MPU_RA_GYRO_CONFIG, INV_FSR_2000DPS << 3);
spiBusWriteRegister(&gyro->bus, MPU_RA_GYRO_CONFIG, INV_FSR_2000DPS << 3);
delayMicroseconds(15);
// Accel +/- 8 G Full Scale
spiWriteRegister(&gyro->bus, MPU_RA_ACCEL_CONFIG, INV_FSR_8G << 3);
spiBusWriteRegister(&gyro->bus, MPU_RA_ACCEL_CONFIG, INV_FSR_8G << 3);
delayMicroseconds(15);
spiWriteRegister(&gyro->bus, MPU_RA_INT_PIN_CFG, 0 << 7 | 0 << 6 | 0 << 5 | 1 << 4 | 0 << 3 | 0 << 2 | 0 << 1 | 0 << 0); // INT_ANYRD_2CLEAR
spiBusWriteRegister(&gyro->bus, MPU_RA_INT_PIN_CFG, 0 << 7 | 0 << 6 | 0 << 5 | 1 << 4 | 0 << 3 | 0 << 2 | 0 << 1 | 0 << 0); // INT_ANYRD_2CLEAR
delayMicroseconds(15);
#ifdef USE_MPU_DATA_READY_SIGNAL
spiWriteRegister(&gyro->bus, MPU_RA_INT_ENABLE, MPU_RF_DATA_RDY_EN);
spiBusWriteRegister(&gyro->bus, MPU_RA_INT_ENABLE, MPU_RF_DATA_RDY_EN);
delayMicroseconds(15);
#endif

4
src/main/drivers/accgyro/accgyro_spi_mpu6500.c
View File

@ -57,7 +57,7 @@ uint8_t mpu6500SpiDetect(const busDevice_t *bus)
{
mpu6500SpiInit(bus);
const uint8_t whoAmI = spiReadRegister(bus, MPU_RA_WHO_AM_I);
const uint8_t whoAmI = spiBusReadRegister(bus, MPU_RA_WHO_AM_I);
uint8_t mpuDetected = MPU_NONE;
switch (whoAmI) {
@ -96,7 +96,7 @@ void mpu6500SpiGyroInit(gyroDev_t *gyro)
mpu6500GyroInit(gyro);
// Disable Primary I2C Interface
spiWriteRegister(&gyro->bus, MPU_RA_USER_CTRL, MPU6500_BIT_I2C_IF_DIS);
spiBusWriteRegister(&gyro->bus, MPU_RA_USER_CTRL, MPU6500_BIT_I2C_IF_DIS);
delay(100);
spiSetDivisor(gyro->bus.busdev_u.spi.instance, SPI_CLOCK_FAST);

8
src/main/drivers/accgyro/accgyro_spi_mpu9250.c
View File

@ -62,12 +62,12 @@ bool mpu9250SpiWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
return true;
}
static bool mpu9250SpiSlowReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t length, uint8_t *data)
static bool mpu9250SpiSlowReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t *data, uint8_t length)
{
IOLo(bus->busdev_u.spi.csnPin);
delayMicroseconds(1);
spiTransferByte(bus->busdev_u.spi.instance, reg | 0x80); // read transaction
spiTransfer(bus->busdev_u.spi.instance, data, NULL, length);
spiTransfer(bus->busdev_u.spi.instance, NULL, data, length);
IOHi(bus->busdev_u.spi.csnPin);
delayMicroseconds(1);
@ -118,7 +118,7 @@ bool mpu9250SpiWriteRegisterVerify(const busDevice_t *bus, uint8_t reg, uint8_t
uint8_t attemptsRemaining = 20;
do {
uint8_t in;
mpu9250SpiSlowReadRegisterBuffer(bus, reg, 1, &in);
mpu9250SpiSlowReadRegisterBuffer(bus, reg, &in, 1);
if (in == data) {
return true;
} else {
@ -180,7 +180,7 @@ uint8_t mpu9250SpiDetect(const busDevice_t *bus)
uint8_t attemptsRemaining = 20;
do {
delay(150);
const uint8_t in = spiReadRegister(bus, MPU_RA_WHO_AM_I);
const uint8_t in = spiBusReadRegister(bus, MPU_RA_WHO_AM_I);
if (in == MPU9250_WHO_AM_I_CONST || in == MPU9255_WHO_AM_I_CONST) {
break;
}

4
src/main/drivers/barometer/barometer_bmp085.c
View File

@ -158,12 +158,12 @@ void bmp085Disable(const bmp085Config_t *config)
bool bmp085ReadRegister(busDevice_t *busdev, uint8_t cmd, uint8_t len, uint8_t *data)
{
return i2cReadRegisterBuffer(busdev, cmd, len, data);
return i2cBusReadRegisterBuffer(busdev, cmd, data, len);
}
bool bmp085WriteRegister(busDevice_t *busdev, uint8_t cmd, uint8_t byte)
{
return i2cWriteRegister(busdev, cmd, byte);
return i2cBusWriteRegister(busdev, cmd, byte);
}
bool bmp085Detect(const bmp085Config_t *config, baroDev_t *baro)

8
src/main/drivers/barometer/barometer_bmp280.c
View File

@ -70,11 +70,11 @@ bool bmp280ReadRegister(busDevice_t *busdev, uint8_t reg, uint8_t length, uint8_
switch (busdev->bustype) {
#ifdef USE_BARO_SPI_BMP280
case BUSTYPE_SPI:
return spiReadRegisterBuffer(busdev, reg | 0x80, length, data);
return spiBusReadRegisterBuffer(busdev, reg | 0x80, data, length);
#endif
#ifdef USE_BARO_BMP280
case BUSTYPE_I2C:
return i2cReadRegisterBuffer(busdev, reg, length, data);
return i2cBusReadRegisterBuffer(busdev, reg, data, length);
#endif
}
return false;
@ -85,11 +85,11 @@ bool bmp280WriteRegister(busDevice_t *busdev, uint8_t reg, uint8_t data)
switch (busdev->bustype) {
#ifdef USE_BARO_SPI_BMP280
case BUSTYPE_SPI:
return spiWriteRegister(busdev, reg & 0x7f, data);
return spiBusWriteRegister(busdev, reg & 0x7f, data);
#endif
#ifdef USE_BARO_BMP280
case BUSTYPE_I2C:
return i2cWriteRegister(busdev, reg, data);
return i2cBusWriteRegister(busdev, reg, data);
#endif
}
return false;

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

@ -66,11 +66,11 @@ bool ms5611ReadCommand(busDevice_t *busdev, uint8_t cmd, uint8_t len, uint8_t *d
switch (busdev->bustype) {
#ifdef USE_BARO_SPI_MS5611
case BUSTYPE_SPI:
return spiReadRegisterBuffer(busdev, cmd | 0x80, len, data);
return spiBusReadRegisterBuffer(busdev, cmd | 0x80, data, len);
#endif
#ifdef USE_BARO_MS5611
case BUSTYPE_I2C:
return i2cReadRegisterBuffer(busdev, cmd, len, data);
return i2cBusReadRegisterBuffer(busdev, cmd, data, len);
#endif
}
return false;
@ -81,11 +81,11 @@ bool ms5611WriteCommand(busDevice_t *busdev, uint8_t cmd, uint8_t byte)
switch (busdev->bustype) {
#ifdef USE_BARO_SPI_MS5611
case BUSTYPE_SPI:
return spiWriteRegister(busdev, cmd & 0x7f, byte);
return spiBusWriteRegister(busdev, cmd & 0x7f, byte);
#endif
#ifdef USE_BARO_MS5611
case BUSTYPE_I2C:
return i2cWriteRegister(busdev, cmd, byte);
return i2cBusWriteRegister(busdev, cmd, byte);
#endif
}
return false;

58
src/main/drivers/bus.c Normal file
View File

@ -0,0 +1,58 @@
/*
* This file is part of Cleanflight.
*
* Cleanflight is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Cleanflight is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdbool.h>
#include <stdint.h>
#include "platform.h"
#include "drivers/bus.h"
#include "drivers/bus_i2c_busdev.h"
#include "drivers/bus_spi.h"
bool busWriteRegister(const busDevice_t *busdev, uint8_t reg, uint8_t data)
{
switch (busdev->bustype) {
case BUSTYPE_SPI:
return spiBusWriteRegister(busdev, reg & 0x7f, data);
case BUSTYPE_I2C:
return i2cBusWriteRegister(busdev, reg, data);
}
return false;
}
bool busReadRegisterBuffer(const busDevice_t *busdev, uint8_t reg, uint8_t *data, uint8_t length)
{
switch (busdev->bustype) {
case BUSTYPE_SPI:
return spiBusReadRegisterBuffer(busdev, reg | 0x80, data, length);
case BUSTYPE_I2C:
return i2cBusReadRegisterBuffer(busdev, reg, data, length);
}
return false;
}
uint8_t busReadRegister(const busDevice_t *busdev, uint8_t reg)
{
switch (busdev->bustype) {
case BUSTYPE_SPI:
return spiBusReadRegister(busdev, reg & 0x7f);
case BUSTYPE_I2C:
return i2cBusReadRegister(busdev, reg);
}
return false;
}

5
src/main/drivers/bus.h
View File

@ -46,3 +46,8 @@ typedef struct busDevice_s {
#ifdef TARGET_BUS_INIT
void targetBusInit(void);
#endif
bool busWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data);
bool busReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t *data, uint8_t length);
uint8_t busReadRegister(const busDevice_t *bus, uint8_t reg);

20
src/main/drivers/bus_i2c_busdev.c
View File

@ -23,17 +23,23 @@
#if defined(USE_I2C)
#include "drivers/bus_i2c.h"
#include "drivers/bus.h"
#include "drivers/bus_i2c.h"
bool i2cReadRegisterBuffer(busDevice_t *busdev, uint8_t reg, uint8_t len, uint8_t *buffer)
{
return i2cRead(busdev->busdev_u.i2c.device, busdev->busdev_u.i2c.address, reg, len, buffer);
}
bool i2cWriteRegister(busDevice_t *busdev, uint8_t reg, uint8_t data)
bool i2cBusWriteRegister(const busDevice_t *busdev, uint8_t reg, uint8_t data)
{
return i2cWrite(busdev->busdev_u.i2c.device, busdev->busdev_u.i2c.address, reg, data);
}
bool i2cBusReadRegisterBuffer(const busDevice_t *busdev, uint8_t reg, uint8_t *data, uint8_t length)
{
return i2cRead(busdev->busdev_u.i2c.device, busdev->busdev_u.i2c.address, reg, length, data);
}
uint8_t i2cBusReadRegister(const busDevice_t *busdev, uint8_t reg)
{
uint8_t data;
i2cRead(busdev->busdev_u.i2c.device, busdev->busdev_u.i2c.address, reg, 1, &data);
return data;
}
#endif

5
src/main/drivers/bus_i2c_busdev.h
View File

@ -17,5 +17,6 @@
#pragma once
bool i2cReadRegisterBuffer(busDevice_t *busdev, uint8_t reg, uint8_t len, uint8_t *buffer);
bool i2cWriteRegister(busDevice_t *busdev, uint8_t reg, uint8_t data);
bool i2cBusWriteRegister(const busDevice_t *busdev, uint8_t reg, uint8_t data);
bool i2cBusReadRegisterBuffer(const busDevice_t *busdev, uint8_t reg, uint8_t *data, uint8_t length);
uint8_t i2cBusReadRegister(const busDevice_t *bus, uint8_t reg);

32
src/main/drivers/bus_spi.c
View File

@ -131,8 +131,7 @@ void spiInitDevice(SPIDevice device)
bool spiInit(SPIDevice device)
{
switch (device)
{
switch (device) {
case SPIINVALID:
return false;
case SPIDEV_1:
@ -170,8 +169,9 @@ bool spiInit(SPIDevice device)
uint32_t spiTimeoutUserCallback(SPI_TypeDef *instance)
{
SPIDevice device = spiDeviceByInstance(instance);
if (device == SPIINVALID)
if (device == SPIINVALID) {
return -1;
}
spiDevice[device].errorCount++;
return spiDevice[device].errorCount;
}
@ -215,7 +215,7 @@ bool spiIsBusBusy(SPI_TypeDef *instance)
}
bool spiTransfer(SPI_TypeDef *instance, uint8_t *rxData, const uint8_t *txData, int len)
bool spiTransfer(SPI_TypeDef *instance, const uint8_t *txData, uint8_t *rxData, int len)
{
uint16_t spiTimeout = 1000;
@ -249,10 +249,10 @@ bool spiTransfer(SPI_TypeDef *instance, uint8_t *rxData, const uint8_t *txData,
return true;
}
bool spiBusTransfer(const busDevice_t *bus, uint8_t *rxData, const uint8_t *txData, int length)
bool spiBusTransfer(const busDevice_t *bus, const uint8_t *txData, uint8_t *rxData, int length)
{
IOLo(bus->busdev_u.spi.csnPin);
spiTransfer(bus->busdev_u.spi.instance, rxData, txData, length);
spiTransfer(bus->busdev_u.spi.instance, txData, rxData, length);
IOHi(bus->busdev_u.spi.csnPin);
return true;
}
@ -260,11 +260,9 @@ bool spiBusTransfer(const busDevice_t *bus, uint8_t *rxData, const uint8_t *txDa
void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor)
{
#define BR_CLEAR_MASK 0xFFC7
uint16_t tempRegister;
SPI_Cmd(instance, DISABLE);
tempRegister = (instance->CR1 & BR_CLEAR_MASK);
const uint16_t tempRegister = (instance->CR1 & BR_CLEAR_MASK);
instance->CR1 = (tempRegister | ((ffs(divisor | 0x100) - 2) << 3));
SPI_Cmd(instance, ENABLE);
@ -273,19 +271,21 @@ void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor)
uint16_t spiGetErrorCounter(SPI_TypeDef *instance)
{
SPIDevice device = spiDeviceByInstance(instance);
if (device == SPIINVALID)
if (device == SPIINVALID) {
return 0;
}
return spiDevice[device].errorCount;
}
void spiResetErrorCounter(SPI_TypeDef *instance)
{
SPIDevice device = spiDeviceByInstance(instance);
if (device != SPIINVALID)
if (device != SPIINVALID) {
spiDevice[device].errorCount = 0;
}
}
bool spiWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
bool spiBusWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
{
IOLo(bus->busdev_u.spi.csnPin);
spiTransferByte(bus->busdev_u.spi.instance, reg);
@ -295,22 +295,22 @@ bool spiWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
return true;
}
bool spiReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t length, uint8_t *data)
bool spiBusReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t *data, uint8_t length)
{
IOLo(bus->busdev_u.spi.csnPin);
spiTransferByte(bus->busdev_u.spi.instance, reg | 0x80); // read transaction
spiTransfer(bus->busdev_u.spi.instance, data, NULL, length);
spiTransfer(bus->busdev_u.spi.instance, NULL, data, length);
IOHi(bus->busdev_u.spi.csnPin);
return true;
}
uint8_t spiReadRegister(const busDevice_t *bus, uint8_t reg)
uint8_t spiBusReadRegister(const busDevice_t *bus, uint8_t reg)
{
uint8_t data;
IOLo(bus->busdev_u.spi.csnPin);
spiTransferByte(bus->busdev_u.spi.instance, reg | 0x80); // read transaction
spiTransfer(bus->busdev_u.spi.instance, &data, NULL, 1);
spiTransfer(bus->busdev_u.spi.instance, NULL, &data, 1);
IOHi(bus->busdev_u.spi.csnPin);
return data;

12
src/main/drivers/bus_spi.h
View File

@ -92,23 +92,23 @@ void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor);
uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t data);
bool spiIsBusBusy(SPI_TypeDef *instance);
bool spiTransfer(SPI_TypeDef *instance, uint8_t *rxData, const uint8_t *txData, int len);
bool spiTransfer(SPI_TypeDef *instance, const uint8_t *txData, uint8_t *rxData, int len);
uint16_t spiGetErrorCounter(SPI_TypeDef *instance);
void spiResetErrorCounter(SPI_TypeDef *instance);
SPIDevice spiDeviceByInstance(SPI_TypeDef *instance);
SPI_TypeDef *spiInstanceByDevice(SPIDevice device);
bool spiBusTransfer(const busDevice_t *bus, uint8_t *rxData, const uint8_t *txData, int length);
bool spiBusTransfer(const busDevice_t *bus, const uint8_t *txData, uint8_t *rxData, int length);
#if defined(USE_HAL_DRIVER)
SPI_HandleTypeDef* spiHandleByInstance(SPI_TypeDef *instance);
DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, uint8_t *pData, uint16_t Size);
DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, const uint8_t *pData, uint16_t Size);
#endif
bool spiWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data);
bool spiReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t length, uint8_t *data);
uint8_t spiReadRegister(const busDevice_t *bus, uint8_t reg);
bool spiBusWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data);
bool spiBusReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t *data, uint8_t length);
uint8_t spiBusReadRegister(const busDevice_t *bus, uint8_t reg);
void spiBusSetInstance(busDevice_t *bus, SPI_TypeDef *instance);
typedef struct spiPinConfig_s {

53
src/main/drivers/bus_spi_hal.c
View File

@ -23,6 +23,8 @@
#ifdef USE_SPI
#include "common/utils.h"
#include "drivers/bus.h"
#include "drivers/bus_spi.h"
#include "drivers/bus_spi_impl.h"
@ -213,8 +215,7 @@ void spiInitDevice(SPIDevice device)
bool spiInit(SPIDevice device)
{
switch (device)
{
switch (device) {
case SPIINVALID:
return false;
case SPIDEV_1:
@ -252,8 +253,9 @@ bool spiInit(SPIDevice device)
uint32_t spiTimeoutUserCallback(SPI_TypeDef *instance)
{
SPIDevice device = spiDeviceByInstance(instance);
if (device == SPIINVALID)
if (device == SPIINVALID) {
return -1;
}
spiDevice[device].errorCount++;
return spiDevice[device].errorCount;
}
@ -270,27 +272,21 @@ bool spiIsBusBusy(SPI_TypeDef *instance)
return false;
}
bool spiTransfer(SPI_TypeDef *instance, uint8_t *rxData, const uint8_t *txData, int len)
bool spiTransfer(SPI_TypeDef *instance, const uint8_t *txData, uint8_t *rxData, int len)
{
SPIDevice device = spiDeviceByInstance(instance);
HAL_StatusTypeDef status;
if (!rxData) // Tx only
{
status = HAL_SPI_Transmit(&spiDevice[device].hspi, (uint8_t *)txData, len, SPI_DEFAULT_TIMEOUT);
}
else if (!txData) // Rx only
{
if (!rxData) { // Tx only
status = HAL_SPI_Transmit(&spiDevice[device].hspi, txData, len, SPI_DEFAULT_TIMEOUT);
} else if (!txData) { // Rx only
status = HAL_SPI_Receive(&spiDevice[device].hspi, rxData, len, SPI_DEFAULT_TIMEOUT);
}
else // Tx and Rx
{
} else { // Tx and Rx
status = HAL_SPI_TransmitReceive(&spiDevice[device].hspi, txData, rxData, len, SPI_DEFAULT_TIMEOUT);
}
if ( status != HAL_OK)
if (status != HAL_OK) {
spiTimeoutUserCallback(instance);
}
return true;
}
@ -303,16 +299,14 @@ static bool spiBusReadBuffer(const busDevice_t *bus, uint8_t *out, int len)
return true;
}
// return uint8_t value or -1 when failure
uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t txByte)
{
uint8_t rxByte;
spiTransfer(instance, &rxByte, &txByte, 1);
spiTransfer(instance, &txByte, &rxByte, 1);
return rxByte;
}
// return uint8_t value or -1 when failure
static uint8_t spiBusTransferByte(const busDevice_t *bus, uint8_t in)
{
const HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(bus->busdev_u.spi.handle, &in, &in, 1, SPI_DEFAULT_TIMEOUT);
@ -322,7 +316,7 @@ static uint8_t spiBusTransferByte(const busDevice_t *bus, uint8_t in)
return in;
}
bool spiBusTransfer(const busDevice_t *bus, uint8_t *rxData, const uint8_t *txData, int len)
bool spiBusTransfer(const busDevice_t *bus, const uint8_t *txData, uint8_t *rxData, int len)
{
IOLo(bus->busdev_u.spi.csnPin);
const HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(bus->busdev_u.spi.handle, txData, rxData, len, SPI_DEFAULT_TIMEOUT);
@ -356,19 +350,21 @@ void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor)
uint16_t spiGetErrorCounter(SPI_TypeDef *instance)
{
SPIDevice device = spiDeviceByInstance(instance);
if (device == SPIINVALID)
if (device == SPIINVALID) {
return 0;
}
return spiDevice[device].errorCount;
}
void spiResetErrorCounter(SPI_TypeDef *instance)
{
SPIDevice device = spiDeviceByInstance(instance);
if (device != SPIINVALID)
if (device != SPIINVALID) {
spiDevice[device].errorCount = 0;
}
}
bool spiWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
bool spiBusWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
{
IOLo(bus->busdev_u.spi.csnPin);
spiBusTransferByte(bus, reg);
@ -378,7 +374,7 @@ bool spiWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
return true;
}
bool spiReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t length, uint8_t *data)
bool spiBusReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t *data, uint8_t length)
{
IOLo(bus->busdev_u.spi.csnPin);
spiBusTransferByte(bus, reg | 0x80); // read transaction
@ -388,7 +384,7 @@ bool spiReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t length,
return true;
}
uint8_t spiReadRegister(const busDevice_t *bus, uint8_t reg)
uint8_t spiBusReadRegister(const busDevice_t *bus, uint8_t reg)
{
uint8_t data;
IOLo(bus->busdev_u.spi.csnPin);
@ -408,12 +404,13 @@ void spiBusSetInstance(busDevice_t *bus, SPI_TypeDef *instance)
void dmaSPIIRQHandler(dmaChannelDescriptor_t* descriptor)
{
SPIDevice device = descriptor->userParam;
if (device != SPIINVALID)
if (device != SPIINVALID) {
HAL_DMA_IRQHandler(&spiDevice[device].hdma);
}
}
DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, uint8_t *pData, uint16_t Size)
DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channel, SPI_TypeDef *Instance, const uint8_t *pData, uint16_t Size)
{
SPIDevice device = spiDeviceByInstance(Instance);
@ -445,7 +442,7 @@ DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channe
//HAL_CLEANCACHE(pData,Size);
// And Transmit
HAL_SPI_Transmit_DMA(&spiDevice[device].hspi, pData, Size);
HAL_SPI_Transmit_DMA(&spiDevice[device].hspi, CONST_CAST(uint8_t*, pData), Size);
return &spiDevice[device].hdma;
}

6
src/main/drivers/compass/compass_ak8963.c
View File

@ -92,7 +92,7 @@ static busDevice_t *bus = NULL;
static bool spiWriteRegisterDelay(const busDevice_t *bus, uint8_t reg, uint8_t data)
{
spiWriteRegister(bus, reg, data);
spiBusWriteRegister(bus, reg, data);
delayMicroseconds(10);
return true;
}
@ -118,7 +118,7 @@ static bool ak8963SensorRead(uint8_t addr_, uint8_t reg_, uint8_t len_, uint8_t
spiWriteRegisterDelay(bus, MPU_RA_I2C_SLV0_CTRL, len_ | 0x80); // read number of bytes
delay(4);
__disable_irq();
bool ack = spiReadRegisterBuffer(bus, MPU_RA_EXT_SENS_DATA_00, len_, buf); // read I2C
bool ack = spiBusReadRegisterBuffer(bus, MPU_RA_EXT_SENS_DATA_00, buf, len_); // read I2C
__enable_irq();
return ack;
}
@ -177,7 +177,7 @@ static bool ak8963SensorCompleteRead(uint8_t *buf)
queuedRead.waiting = false;
spiReadRegisterBuffer(bus, MPU_RA_EXT_SENS_DATA_00, queuedRead.len, buf); // read I2C buffer
spiBusReadRegisterBuffer(bus, MPU_RA_EXT_SENS_DATA_00, buf, queuedRead.len); // read I2C buffer
return true;
}
#else

2
src/main/drivers/compass/compass_spi_hmc5883l.c
View File

@ -44,7 +44,7 @@ bool hmc5883SpiWriteCommand(uint8_t reg, uint8_t data)
//spiTransferByte(HMC5883_SPI_INSTANCE, reg & 0x7F);
//spiTransferByte(HMC5883_SPI_INSTANCE, data);
spiTransfer(HMC5883_SPI_INSTANCE, NULL, buf, 2);
spiTransfer(HMC5883_SPI_INSTANCE, buf, NULL, 2);
DISABLE_HMC5883;
return true;

29
src/main/drivers/flash_m25p16.c
View File

@ -98,12 +98,12 @@ static void m25p16_writeEnable(void)
static uint8_t m25p16_readStatus(void)
{
uint8_t command[2] = { M25P16_INSTRUCTION_READ_STATUS_REG, 0 };
const uint8_t command[2] = { M25P16_INSTRUCTION_READ_STATUS_REG, 0 };
uint8_t in[2];
ENABLE_M25P16;
spiTransfer(M25P16_SPI_INSTANCE, in, command, sizeof(command));
spiTransfer(M25P16_SPI_INSTANCE, command, in, sizeof(command));
DISABLE_M25P16;
@ -137,26 +137,25 @@ bool m25p16_waitForReady(uint32_t timeoutMillis)
*/
static bool m25p16_readIdentification(void)
{
uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0 };
uint8_t in[4];
uint32_t chipID;
const uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0 };
delay(50); // short delay required after initialisation of SPI device instance.
/* Just in case transfer fails and writes nothing, so we don't try to verify the ID against random garbage
* from the stack:
*/
uint8_t in[4];
in[1] = 0;
ENABLE_M25P16;
spiTransfer(M25P16_SPI_INSTANCE, in, out, sizeof(out));
spiTransfer(M25P16_SPI_INSTANCE, out, in, sizeof(out));
// Clearing the CS bit terminates the command early so we don't have to read the chip UID:
DISABLE_M25P16;
// Manufacturer, memory type, and capacity
chipID = (in[1] << 16) | (in[2] << 8) | (in[3]);
const uint32_t chipID = (in[1] << 16) | (in[2] << 8) | (in[3]);
// All supported chips use the same pagesize of 256 bytes
@ -241,7 +240,7 @@ bool m25p16_init(const flashConfig_t *flashConfig)
*/
void m25p16_eraseSector(uint32_t address)
{
uint8_t out[] = { M25P16_INSTRUCTION_SECTOR_ERASE, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF};
const uint8_t out[] = { M25P16_INSTRUCTION_SECTOR_ERASE, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF};
m25p16_waitForReady(SECTOR_ERASE_TIMEOUT_MILLIS);
@ -249,7 +248,7 @@ void m25p16_eraseSector(uint32_t address)
ENABLE_M25P16;
spiTransfer(M25P16_SPI_INSTANCE, NULL, out, sizeof(out));
spiTransfer(M25P16_SPI_INSTANCE, out, NULL, sizeof(out));
DISABLE_M25P16;
}
@ -265,7 +264,7 @@ void m25p16_eraseCompletely(void)
void m25p16_pageProgramBegin(uint32_t address)
{
uint8_t command[] = { M25P16_INSTRUCTION_PAGE_PROGRAM, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF};
const uint8_t command[] = { M25P16_INSTRUCTION_PAGE_PROGRAM, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF};
m25p16_waitForReady(DEFAULT_TIMEOUT_MILLIS);
@ -273,12 +272,12 @@ void m25p16_pageProgramBegin(uint32_t address)
ENABLE_M25P16;
spiTransfer(M25P16_SPI_INSTANCE, NULL, command, sizeof(command));
spiTransfer(M25P16_SPI_INSTANCE, command, NULL, sizeof(command));
}
void m25p16_pageProgramContinue(const uint8_t *data, int length)
{
spiTransfer(M25P16_SPI_INSTANCE, NULL, data, length);
spiTransfer(M25P16_SPI_INSTANCE, data, NULL, length);
}
void m25p16_pageProgramFinish(void)
@ -320,7 +319,7 @@ void m25p16_pageProgram(uint32_t address, const uint8_t *data, int length)
*/
int m25p16_readBytes(uint32_t address, uint8_t *buffer, int length)
{
uint8_t command[] = { M25P16_INSTRUCTION_READ_BYTES, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF};
const uint8_t command[] = { M25P16_INSTRUCTION_READ_BYTES, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF};
if (!m25p16_waitForReady(DEFAULT_TIMEOUT_MILLIS)) {
return 0;
@ -328,8 +327,8 @@ int m25p16_readBytes(uint32_t address, uint8_t *buffer, int length)
ENABLE_M25P16;
spiTransfer(M25P16_SPI_INSTANCE, NULL, command, sizeof(command));
spiTransfer(M25P16_SPI_INSTANCE, buffer, NULL, length);
spiTransfer(M25P16_SPI_INSTANCE, command, NULL, sizeof(command));
spiTransfer(M25P16_SPI_INSTANCE, NULL, buffer, length);
DISABLE_M25P16;

16
src/main/drivers/sdcard.c
View File

@ -258,7 +258,7 @@ static uint8_t sdcard_waitForNonIdleByte(int maxDelay)
*/
static uint8_t sdcard_sendCommand(uint8_t commandCode, uint32_t commandArgument)
{
uint8_t command[6] = {
const uint8_t command[6] = {
0x40 | commandCode,
commandArgument >> 24,
commandArgument >> 16,
@ -272,7 +272,7 @@ static uint8_t sdcard_sendCommand(uint8_t commandCode, uint32_t commandArgument)
if (!sdcard_waitForIdle(SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY) && commandCode != SDCARD_COMMAND_GO_IDLE_STATE)
return 0xFF;
spiTransfer(SDCARD_SPI_INSTANCE, NULL, command, sizeof(command));
spiTransfer(SDCARD_SPI_INSTANCE, command, NULL, sizeof(command));
/*
* The card can take up to SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY bytes to send the response, in the meantime
@ -308,7 +308,7 @@ static bool sdcard_validateInterfaceCondition(void)
// V1 cards don't support this command
sdcard.version = 1;
} else if (status == SDCARD_R1_STATUS_BIT_IDLE) {
spiTransfer(SDCARD_SPI_INSTANCE, ifCondReply, NULL, sizeof(ifCondReply));
spiTransfer(SDCARD_SPI_INSTANCE, NULL, ifCondReply, sizeof(ifCondReply));
/*
* We don't bother to validate the SDCard's operating voltage range since the spec requires it to accept our
@ -332,7 +332,7 @@ static bool sdcard_readOCRRegister(uint32_t *result)
uint8_t response[4];
spiTransfer(SDCARD_SPI_INSTANCE, response, NULL, sizeof(response));
spiTransfer(SDCARD_SPI_INSTANCE, NULL, response, sizeof(response));
if (status == 0) {
sdcard_deselect();
@ -370,7 +370,7 @@ static sdcardReceiveBlockStatus_e sdcard_receiveDataBlock(uint8_t *buffer, int c
return SDCARD_RECEIVE_ERROR;
}
spiTransfer(SDCARD_SPI_INSTANCE, buffer, NULL, count);
spiTransfer(SDCARD_SPI_INSTANCE, NULL, buffer, count);
// Discard trailing CRC, we don't care
spiTransferByte(SDCARD_SPI_INSTANCE, 0xFF);
@ -405,7 +405,7 @@ static bool sdcard_sendDataBlockFinish(void)
/**
* Begin sending a buffer of SDCARD_BLOCK_SIZE bytes to the SD card.
*/
static void sdcard_sendDataBlockBegin(uint8_t *buffer, bool multiBlockWrite)
static void sdcard_sendDataBlockBegin(const uint8_t *buffer, bool multiBlockWrite)
{
// Card wants 8 dummy clock cycles between the write command's response and a data block beginning:
spiTransferByte(SDCARD_SPI_INSTANCE, 0xFF);
@ -455,7 +455,7 @@ static void sdcard_sendDataBlockBegin(uint8_t *buffer, bool multiBlockWrite)
}
else {
// Send the first chunk now
spiTransfer(SDCARD_SPI_INSTANCE, NULL, buffer, SDCARD_NON_DMA_CHUNK_SIZE);
spiTransfer(SDCARD_SPI_INSTANCE, buffer, NULL, SDCARD_NON_DMA_CHUNK_SIZE);
}
}
@ -786,7 +786,7 @@ bool sdcard_poll(void)
#endif
if (!useDMAForTx) {
// Send another chunk
spiTransfer(SDCARD_SPI_INSTANCE, NULL, sdcard.pendingOperation.buffer + SDCARD_NON_DMA_CHUNK_SIZE * sdcard.pendingOperation.chunkIndex, SDCARD_NON_DMA_CHUNK_SIZE);
spiTransfer(SDCARD_SPI_INSTANCE, sdcard.pendingOperation.buffer + SDCARD_NON_DMA_CHUNK_SIZE * sdcard.pendingOperation.chunkIndex, NULL, SDCARD_NON_DMA_CHUNK_SIZE);
sdcard.pendingOperation.chunkIndex++;

4
src/main/target/NAZE/hardware_revision.c
View File

@ -63,14 +63,14 @@ uint8_t detectSpiDevice(void)
nazeSpiCsPin = IOGetByTag(IO_TAG(NAZE_SPI_CS_PIN));
#endif
uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0 };
const uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0 };
uint8_t in[4];
uint32_t flash_id;
// try autodetect flash chip
delay(50); // short delay required after initialisation of SPI device instance.
ENABLE_SPI_CS;
spiTransfer(NAZE_SPI_INSTANCE, in, out, sizeof(out));
spiTransfer(NAZE_SPI_INSTANCE, out, in, sizeof(out));
DISABLE_SPI_CS;
flash_id = in[1] << 16 | in[2] << 8 | in[3];

24
src/test/unit/baro_bmp280_unittest.cc
View File

@ -18,6 +18,11 @@
extern "C" {
#include "platform.h"
#include "target.h"
#include "drivers/barometer/barometer.h"
#include "drivers/bus.h"
void bmp280_calculate(int32_t *pressure, int32_t *temperature);
extern uint32_t bmp280_up;
@ -139,22 +144,11 @@ TEST(baroBmp280Test, TestBmp280CalculateZeroP)
extern "C" {
void delay(uint32_t) {}
bool i2cBusReadRegisterBuffer(busDevice_t*, uint8_t, uint8_t*, uint8_t) {return true;}
bool i2cBusWriteRegister(busDevice_t*, uint8_t, uint8_t) {return true;}
bool spiBusReadRegisterBuffer(busDevice_t*, uint8_t, uint8_t*, uint8_t) {return true;}
bool spiBusWriteRegister(busDevice_t*, uint8_t, uint8_t) {return true;}
bool i2cWriteRegister(uint8_t, uint8_t, uint8_t) {
return true;
}
bool i2cReadRegisterBuffer(uint8_t, uint8_t, uint8_t, uint8_t) {
return true;
}
bool spiWriteRegister(uint8_t, uint8_t, uint8_t) {
return true;
}
bool spiReadRegisterBuffer(uint8_t, uint8_t, uint8_t, uint8_t) {
return true;
}
void spiSetDivisor() {
}

24
src/test/unit/baro_ms5611_unittest.cc
View File

@ -18,6 +18,11 @@
extern "C" {
#include "platform.h"
#include "target.h"
#include "drivers/barometer/barometer.h"
#include "drivers/bus.h"
int8_t ms5611_crc(uint16_t *prom);
void ms5611_calculate(int32_t *pressure, int32_t *temperature);
@ -141,21 +146,10 @@ extern "C" {
void delay(uint32_t) {}
void delayMicroseconds(uint32_t) {}
bool i2cWriteRegister(uint8_t, uint8_t, uint8_t) {
return true;
}
bool i2cReadRegisterBuffer(uint8_t, uint8_t, uint8_t, uint8_t) {
return true;
}
bool spiWriteRegister(uint8_t, uint8_t, uint8_t) {
return true;
}
bool spiReadRegisterBuffer(uint8_t, uint8_t, uint8_t, uint8_t) {
return true;
}
bool i2cBusReadRegisterBuffer(busDevice_t*, uint8_t, uint8_t*, uint8_t) {return true;}
bool i2cBusWriteRegister(busDevice_t*, uint8_t, uint8_t) {return true;}
bool spiBusReadRegisterBuffer(busDevice_t*, uint8_t, uint8_t*, uint8_t) {return true;}
bool spiBusWriteRegister(busDevice_t*, uint8_t, uint8_t) {return true;}
void spiSetDivisor() {
}