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

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

@ -125,7 +125,7 @@
// RF = Register Flag // RF = Register Flag
#define MPU_RF_DATA_RDY_EN (1 << 0) #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 bool (*mpuWriteRegisterFnPtr)(const busDevice_t *bus, uint8_t reg, uint8_t data);
typedef void (*mpuResetFnPtr)(void); typedef void (*mpuResetFnPtr)(void);
@ -190,9 +190,6 @@ typedef struct mpuDetectionResult_s {
mpu6050Resolution_e resolution; mpu6050Resolution_e resolution;
} mpuDetectionResult_t; } 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; struct gyroDev_s;
void mpuGyroInit(struct gyroDev_s *gyro); void mpuGyroInit(struct gyroDev_s *gyro);
struct accDev_s; 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]; 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) { if (!ack) {
return false; return false;
} }
@ -83,7 +83,7 @@ static bool mpu3050GyroRead(gyroDev_t *gyro)
static bool mpu3050ReadTemperature(gyroDev_t *gyro, int16_t *tempData) static bool mpu3050ReadTemperature(gyroDev_t *gyro, int16_t *tempData)
{ {
uint8_t buf[2]; 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; 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); spiSetDivisor(bus->busdev_u.spi.instance, BMI160_SPI_DIVISOR);
/* Read this address to acticate SPI (see p. 84) */ /* Read this address to activate SPI (see p. 84) */
spiReadRegister(bus, 0x7F); spiBusReadRegister(bus, 0x7F);
delay(10); // Give SPI some time to start up delay(10); // Give SPI some time to start up
/* Check the chip ID */ /* Check the chip ID */
if (spiReadRegister(bus, BMI160_REG_CHIPID) != 0xd1) { if (spiBusReadRegister(bus, BMI160_REG_CHIPID) != 0xd1) {
return MPU_NONE; return MPU_NONE;
} }
@ -162,7 +162,7 @@ static int32_t BMI160_Config(const busDevice_t *bus)
delay(5); // can take up to 3.8ms delay(5); // can take up to 3.8ms
// Verify that normal power mode was entered // 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){ if ((pmu_status & 0x3C) != 0x14){
return -3; return -3;
} }
@ -191,7 +191,7 @@ static int32_t BMI160_Config(const busDevice_t *bus)
delay(1); delay(1);
// Enable offset compensation // 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) { if (BMI160_WriteReg(bus, BMI160_REG_OFFSET_0, val | 0xC0) != 0) {
return -7; return -7;
} }
@ -232,7 +232,7 @@ static int32_t BMI160_do_foc(const busDevice_t *bus)
// Wait for FOC to complete // Wait for FOC to complete
for (int i=0; i<50; i++) { 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) { if (val & BMI160_REG_STATUS_FOC_RDY) {
break; break;
} }
@ -243,7 +243,7 @@ static int32_t BMI160_do_foc(const busDevice_t *bus)
} }
// Program NVM // 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) { if (BMI160_WriteReg(bus, BMI160_REG_CONF, val | BMI160_REG_CONF_NVM_PROG_EN) != 0) {
return -4; return -4;
} }
@ -254,7 +254,7 @@ static int32_t BMI160_do_foc(const busDevice_t *bus)
// Wait for NVM programming to complete // Wait for NVM programming to complete
for (int i=0; i<50; i++) { 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) { if (val & BMI160_REG_STATUS_NVM_RDY) {
break; break;
} }
@ -321,16 +321,16 @@ bool bmi160AccRead(accDev_t *acc)
BUFFER_SIZE, BUFFER_SIZE,
}; };
uint8_t bmi160_rec_buf[BUFFER_SIZE]; uint8_t bmi160_rx_buf[BUFFER_SIZE];
uint8_t bmi160_tx_buf[BUFFER_SIZE] = {BMI160_REG_ACC_DATA_X_LSB | 0x80, 0, 0, 0, 0, 0, 0}; 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); 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); 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[X] = (int16_t)((bmi160_rx_buf[IDX_ACCEL_XOUT_H] << 8) | bmi160_rx_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[Y] = (int16_t)((bmi160_rx_buf[IDX_ACCEL_YOUT_H] << 8) | bmi160_rx_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[Z] = (int16_t)((bmi160_rx_buf[IDX_ACCEL_ZOUT_H] << 8) | bmi160_rx_buf[IDX_ACCEL_ZOUT_L]);
return true; return true;
} }
@ -349,16 +349,16 @@ bool bmi160GyroRead(gyroDev_t *gyro)
BUFFER_SIZE, 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}; 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); 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); 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[X] = (int16_t)((bmi160_rx_buf[IDX_GYRO_XOUT_H] << 8) | bmi160_rx_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[Y] = (int16_t)((bmi160_rx_buf[IDX_GYRO_YOUT_H] << 8) | bmi160_rx_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[Z] = (int16_t)((bmi160_rx_buf[IDX_GYRO_ZOUT_H] << 8) | bmi160_rx_buf[IDX_GYRO_ZOUT_L]);
return true; 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 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; uint8_t attemptsRemaining = 20;
do { do {
delay(150); 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) { if (whoAmI == ICM20689_WHO_AM_I_CONST) {
break; 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); spiSetDivisor(gyro->bus.busdev_u.spi.instance, SPI_CLOCK_INITIALIZATON);
// Accel and Gyro DLPF Setting // Accel and Gyro DLPF Setting
spiWriteRegister(&gyro->bus, MPU6000_CONFIG, gyro->lpf); spiBusWriteRegister(&gyro->bus, MPU6000_CONFIG, gyro->lpf);
delayMicroseconds(1); delayMicroseconds(1);
spiSetDivisor(gyro->bus.busdev_u.spi.instance, SPI_CLOCK_FAST); // 18 MHz SPI clock 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); 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; uint8_t attemptsRemaining = 5;
do { do {
delay(150); 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) { if (whoAmI == MPU6000_WHO_AM_I_CONST) {
break; break;
} }
@ -148,7 +148,7 @@ uint8_t mpu6000SpiDetect(const busDevice_t *bus)
} }
} while (attemptsRemaining--); } 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 */ /* 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); spiSetDivisor(gyro->bus.busdev_u.spi.instance, SPI_CLOCK_INITIALIZATON);
// Device Reset // 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); 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); delay(150);
// Clock Source PPL with Z axis gyro reference // 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); delayMicroseconds(15);
// Disable Primary I2C Interface // 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); delayMicroseconds(15);
spiWriteRegister(&gyro->bus, MPU_RA_PWR_MGMT_2, 0x00); spiBusWriteRegister(&gyro->bus, MPU_RA_PWR_MGMT_2, 0x00);
delayMicroseconds(15); delayMicroseconds(15);
// Accel Sample Rate 1kHz // Accel Sample Rate 1kHz
// Gyroscope Output Rate = 1kHz when the DLPF is enabled // 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); delayMicroseconds(15);
// Gyro +/- 1000 DPS Full Scale // 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); delayMicroseconds(15);
// Accel +/- 8 G Full Scale // 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); 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); delayMicroseconds(15);
#ifdef USE_MPU_DATA_READY_SIGNAL #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); delayMicroseconds(15);
#endif #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); 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; uint8_t mpuDetected = MPU_NONE;
switch (whoAmI) { switch (whoAmI) {
@ -96,7 +96,7 @@ void mpu6500SpiGyroInit(gyroDev_t *gyro)
mpu6500GyroInit(gyro); mpu6500GyroInit(gyro);
// Disable Primary I2C Interface // 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); delay(100);
spiSetDivisor(gyro->bus.busdev_u.spi.instance, SPI_CLOCK_FAST); 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; 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); IOLo(bus->busdev_u.spi.csnPin);
delayMicroseconds(1); delayMicroseconds(1);
spiTransferByte(bus->busdev_u.spi.instance, reg | 0x80); // read transaction 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); IOHi(bus->busdev_u.spi.csnPin);
delayMicroseconds(1); delayMicroseconds(1);
@ -118,7 +118,7 @@ bool mpu9250SpiWriteRegisterVerify(const busDevice_t *bus, uint8_t reg, uint8_t
uint8_t attemptsRemaining = 20; uint8_t attemptsRemaining = 20;
do { do {
uint8_t in; uint8_t in;
mpu9250SpiSlowReadRegisterBuffer(bus, reg, 1, &in); mpu9250SpiSlowReadRegisterBuffer(bus, reg, &in, 1);
if (in == data) { if (in == data) {
return true; return true;
} else { } else {
@ -180,7 +180,7 @@ uint8_t mpu9250SpiDetect(const busDevice_t *bus)
uint8_t attemptsRemaining = 20; uint8_t attemptsRemaining = 20;
do { do {
delay(150); 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) { if (in == MPU9250_WHO_AM_I_CONST || in == MPU9255_WHO_AM_I_CONST) {
break; 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) 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) 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) 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) { switch (busdev->bustype) {
#ifdef USE_BARO_SPI_BMP280 #ifdef USE_BARO_SPI_BMP280
case BUSTYPE_SPI: case BUSTYPE_SPI:
return spiReadRegisterBuffer(busdev, reg | 0x80, length, data); return spiBusReadRegisterBuffer(busdev, reg | 0x80, data, length);
#endif #endif
#ifdef USE_BARO_BMP280 #ifdef USE_BARO_BMP280
case BUSTYPE_I2C: case BUSTYPE_I2C:
return i2cReadRegisterBuffer(busdev, reg, length, data); return i2cBusReadRegisterBuffer(busdev, reg, data, length);
#endif #endif
} }
return false; return false;
@ -85,11 +85,11 @@ bool bmp280WriteRegister(busDevice_t *busdev, uint8_t reg, uint8_t data)
switch (busdev->bustype) { switch (busdev->bustype) {
#ifdef USE_BARO_SPI_BMP280 #ifdef USE_BARO_SPI_BMP280
case BUSTYPE_SPI: case BUSTYPE_SPI:
return spiWriteRegister(busdev, reg & 0x7f, data); return spiBusWriteRegister(busdev, reg & 0x7f, data);
#endif #endif
#ifdef USE_BARO_BMP280 #ifdef USE_BARO_BMP280
case BUSTYPE_I2C: case BUSTYPE_I2C:
return i2cWriteRegister(busdev, reg, data); return i2cBusWriteRegister(busdev, reg, data);
#endif #endif
} }
return false; 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) { switch (busdev->bustype) {
#ifdef USE_BARO_SPI_MS5611 #ifdef USE_BARO_SPI_MS5611
case BUSTYPE_SPI: case BUSTYPE_SPI:
return spiReadRegisterBuffer(busdev, cmd | 0x80, len, data); return spiBusReadRegisterBuffer(busdev, cmd | 0x80, data, len);
#endif #endif
#ifdef USE_BARO_MS5611 #ifdef USE_BARO_MS5611
case BUSTYPE_I2C: case BUSTYPE_I2C:
return i2cReadRegisterBuffer(busdev, cmd, len, data); return i2cBusReadRegisterBuffer(busdev, cmd, data, len);
#endif #endif
} }
return false; return false;
@ -81,11 +81,11 @@ bool ms5611WriteCommand(busDevice_t *busdev, uint8_t cmd, uint8_t byte)
switch (busdev->bustype) { switch (busdev->bustype) {
#ifdef USE_BARO_SPI_MS5611 #ifdef USE_BARO_SPI_MS5611
case BUSTYPE_SPI: case BUSTYPE_SPI:
return spiWriteRegister(busdev, cmd & 0x7f, byte); return spiBusWriteRegister(busdev, cmd & 0x7f, byte);
#endif #endif
#ifdef USE_BARO_MS5611 #ifdef USE_BARO_MS5611
case BUSTYPE_I2C: case BUSTYPE_I2C:
return i2cWriteRegister(busdev, cmd, byte); return i2cBusWriteRegister(busdev, cmd, byte);
#endif #endif
} }
return false; 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 #ifdef TARGET_BUS_INIT
void targetBusInit(void); void targetBusInit(void);
#endif #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) #if defined(USE_I2C)
#include "drivers/bus_i2c.h"
#include "drivers/bus.h" #include "drivers/bus.h"
#include "drivers/bus_i2c.h"
bool i2cReadRegisterBuffer(busDevice_t *busdev, uint8_t reg, uint8_t len, uint8_t *buffer) bool i2cBusWriteRegister(const busDevice_t *busdev, uint8_t reg, uint8_t data)
{
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)
{ {
return i2cWrite(busdev->busdev_u.i2c.device, busdev->busdev_u.i2c.address, reg, 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 #endif

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

@ -17,5 +17,6 @@
#pragma once #pragma once
bool i2cReadRegisterBuffer(busDevice_t *busdev, uint8_t reg, uint8_t len, uint8_t *buffer); bool i2cBusWriteRegister(const busDevice_t *busdev, uint8_t reg, uint8_t data);
bool i2cWriteRegister(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) bool spiInit(SPIDevice device)
{ {
switch (device) switch (device) {
{
case SPIINVALID: case SPIINVALID:
return false; return false;
case SPIDEV_1: case SPIDEV_1:
@ -170,8 +169,9 @@ bool spiInit(SPIDevice device)
uint32_t spiTimeoutUserCallback(SPI_TypeDef *instance) uint32_t spiTimeoutUserCallback(SPI_TypeDef *instance)
{ {
SPIDevice device = spiDeviceByInstance(instance); SPIDevice device = spiDeviceByInstance(instance);
if (device == SPIINVALID) if (device == SPIINVALID) {
return -1; return -1;
}
spiDevice[device].errorCount++; spiDevice[device].errorCount++;
return 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; uint16_t spiTimeout = 1000;
@ -249,10 +249,10 @@ bool spiTransfer(SPI_TypeDef *instance, uint8_t *rxData, const uint8_t *txData,
return true; 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); 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); IOHi(bus->busdev_u.spi.csnPin);
return true; 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) void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor)
{ {
#define BR_CLEAR_MASK 0xFFC7 #define BR_CLEAR_MASK 0xFFC7
uint16_t tempRegister;
SPI_Cmd(instance, DISABLE); 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)); instance->CR1 = (tempRegister | ((ffs(divisor | 0x100) - 2) << 3));
SPI_Cmd(instance, ENABLE); SPI_Cmd(instance, ENABLE);
@ -273,19 +271,21 @@ void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor)
uint16_t spiGetErrorCounter(SPI_TypeDef *instance) uint16_t spiGetErrorCounter(SPI_TypeDef *instance)
{ {
SPIDevice device = spiDeviceByInstance(instance); SPIDevice device = spiDeviceByInstance(instance);
if (device == SPIINVALID) if (device == SPIINVALID) {
return 0; return 0;
}
return spiDevice[device].errorCount; return spiDevice[device].errorCount;
} }
void spiResetErrorCounter(SPI_TypeDef *instance) void spiResetErrorCounter(SPI_TypeDef *instance)
{ {
SPIDevice device = spiDeviceByInstance(instance); SPIDevice device = spiDeviceByInstance(instance);
if (device != SPIINVALID) if (device != SPIINVALID) {
spiDevice[device].errorCount = 0; 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); IOLo(bus->busdev_u.spi.csnPin);
spiTransferByte(bus->busdev_u.spi.instance, reg); 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; 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); IOLo(bus->busdev_u.spi.csnPin);
spiTransferByte(bus->busdev_u.spi.instance, reg | 0x80); // read transaction 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); IOHi(bus->busdev_u.spi.csnPin);
return true; 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; uint8_t data;
IOLo(bus->busdev_u.spi.csnPin); IOLo(bus->busdev_u.spi.csnPin);
spiTransferByte(bus->busdev_u.spi.instance, reg | 0x80); // read transaction 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); IOHi(bus->busdev_u.spi.csnPin);
return data; 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); uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t data);
bool spiIsBusBusy(SPI_TypeDef *instance); 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); uint16_t spiGetErrorCounter(SPI_TypeDef *instance);
void spiResetErrorCounter(SPI_TypeDef *instance); void spiResetErrorCounter(SPI_TypeDef *instance);
SPIDevice spiDeviceByInstance(SPI_TypeDef *instance); SPIDevice spiDeviceByInstance(SPI_TypeDef *instance);
SPI_TypeDef *spiInstanceByDevice(SPIDevice device); 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) #if defined(USE_HAL_DRIVER)
SPI_HandleTypeDef* spiHandleByInstance(SPI_TypeDef *instance); 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 #endif
bool spiWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data); bool spiBusWriteRegister(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); bool spiBusReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t *data, uint8_t length);
uint8_t spiReadRegister(const busDevice_t *bus, uint8_t reg); uint8_t spiBusReadRegister(const busDevice_t *bus, uint8_t reg);
void spiBusSetInstance(busDevice_t *bus, SPI_TypeDef *instance); void spiBusSetInstance(busDevice_t *bus, SPI_TypeDef *instance);
typedef struct spiPinConfig_s { typedef struct spiPinConfig_s {

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

@ -23,6 +23,8 @@
#ifdef USE_SPI #ifdef USE_SPI
#include "common/utils.h"
#include "drivers/bus.h" #include "drivers/bus.h"
#include "drivers/bus_spi.h" #include "drivers/bus_spi.h"
#include "drivers/bus_spi_impl.h" #include "drivers/bus_spi_impl.h"
@ -213,8 +215,7 @@ void spiInitDevice(SPIDevice device)
bool spiInit(SPIDevice device) bool spiInit(SPIDevice device)
{ {
switch (device) switch (device) {
{
case SPIINVALID: case SPIINVALID:
return false; return false;
case SPIDEV_1: case SPIDEV_1:
@ -252,8 +253,9 @@ bool spiInit(SPIDevice device)
uint32_t spiTimeoutUserCallback(SPI_TypeDef *instance) uint32_t spiTimeoutUserCallback(SPI_TypeDef *instance)
{ {
SPIDevice device = spiDeviceByInstance(instance); SPIDevice device = spiDeviceByInstance(instance);
if (device == SPIINVALID) if (device == SPIINVALID) {
return -1; return -1;
}
spiDevice[device].errorCount++; spiDevice[device].errorCount++;
return spiDevice[device].errorCount; return spiDevice[device].errorCount;
} }
@ -270,27 +272,21 @@ bool spiIsBusBusy(SPI_TypeDef *instance)
return false; 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); SPIDevice device = spiDeviceByInstance(instance);
HAL_StatusTypeDef status; HAL_StatusTypeDef status;
if (!rxData) // Tx only if (!rxData) { // Tx only
{ status = HAL_SPI_Transmit(&spiDevice[device].hspi, txData, len, SPI_DEFAULT_TIMEOUT);
status = HAL_SPI_Transmit(&spiDevice[device].hspi, (uint8_t *)txData, len, SPI_DEFAULT_TIMEOUT); } else if (!txData) { // Rx only
}
else if (!txData) // Rx only
{
status = HAL_SPI_Receive(&spiDevice[device].hspi, rxData, len, SPI_DEFAULT_TIMEOUT); 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); status = HAL_SPI_TransmitReceive(&spiDevice[device].hspi, txData, rxData, len, SPI_DEFAULT_TIMEOUT);
} }
if (status != HAL_OK) {
if ( status != HAL_OK)
spiTimeoutUserCallback(instance); spiTimeoutUserCallback(instance);
}
return true; return true;
} }
@ -303,16 +299,14 @@ static bool spiBusReadBuffer(const busDevice_t *bus, uint8_t *out, int len)
return true; return true;
} }
// return uint8_t value or -1 when failure
uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t txByte) uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t txByte)
{ {
uint8_t rxByte; uint8_t rxByte;
spiTransfer(instance, &rxByte, &txByte, 1); spiTransfer(instance, &txByte, &rxByte, 1);
return rxByte; return rxByte;
} }
// return uint8_t value or -1 when failure
static uint8_t spiBusTransferByte(const busDevice_t *bus, uint8_t in) 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); 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; 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); IOLo(bus->busdev_u.spi.csnPin);
const HAL_StatusTypeDef status = HAL_SPI_TransmitReceive(bus->busdev_u.spi.handle, txData, rxData, len, SPI_DEFAULT_TIMEOUT); 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) uint16_t spiGetErrorCounter(SPI_TypeDef *instance)
{ {
SPIDevice device = spiDeviceByInstance(instance); SPIDevice device = spiDeviceByInstance(instance);
if (device == SPIINVALID) if (device == SPIINVALID) {
return 0; return 0;
}
return spiDevice[device].errorCount; return spiDevice[device].errorCount;
} }
void spiResetErrorCounter(SPI_TypeDef *instance) void spiResetErrorCounter(SPI_TypeDef *instance)
{ {
SPIDevice device = spiDeviceByInstance(instance); SPIDevice device = spiDeviceByInstance(instance);
if (device != SPIINVALID) if (device != SPIINVALID) {
spiDevice[device].errorCount = 0; 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); IOLo(bus->busdev_u.spi.csnPin);
spiBusTransferByte(bus, reg); spiBusTransferByte(bus, reg);
@ -378,7 +374,7 @@ bool spiWriteRegister(const busDevice_t *bus, uint8_t reg, uint8_t data)
return true; 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); IOLo(bus->busdev_u.spi.csnPin);
spiBusTransferByte(bus, reg | 0x80); // read transaction spiBusTransferByte(bus, reg | 0x80); // read transaction
@ -388,7 +384,7 @@ bool spiReadRegisterBuffer(const busDevice_t *bus, uint8_t reg, uint8_t length,
return true; 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; uint8_t data;
IOLo(bus->busdev_u.spi.csnPin); IOLo(bus->busdev_u.spi.csnPin);
@ -408,12 +404,13 @@ void spiBusSetInstance(busDevice_t *bus, SPI_TypeDef *instance)
void dmaSPIIRQHandler(dmaChannelDescriptor_t* descriptor) void dmaSPIIRQHandler(dmaChannelDescriptor_t* descriptor)
{ {
SPIDevice device = descriptor->userParam; SPIDevice device = descriptor->userParam;
if (device != SPIINVALID) if (device != SPIINVALID) {
HAL_DMA_IRQHandler(&spiDevice[device].hdma); 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); SPIDevice device = spiDeviceByInstance(Instance);
@ -445,7 +442,7 @@ DMA_HandleTypeDef* spiSetDMATransmit(DMA_Stream_TypeDef *Stream, uint32_t Channe
//HAL_CLEANCACHE(pData,Size); //HAL_CLEANCACHE(pData,Size);
// And Transmit // 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; 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) static bool spiWriteRegisterDelay(const busDevice_t *bus, uint8_t reg, uint8_t data)
{ {
spiWriteRegister(bus, reg, data); spiBusWriteRegister(bus, reg, data);
delayMicroseconds(10); delayMicroseconds(10);
return true; 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 spiWriteRegisterDelay(bus, MPU_RA_I2C_SLV0_CTRL, len_ | 0x80); // read number of bytes
delay(4); delay(4);
__disable_irq(); __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(); __enable_irq();
return ack; return ack;
} }
@ -177,7 +177,7 @@ static bool ak8963SensorCompleteRead(uint8_t *buf)
queuedRead.waiting = false; 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; return true;
} }
#else #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, reg & 0x7F);
//spiTransferByte(HMC5883_SPI_INSTANCE, data); //spiTransferByte(HMC5883_SPI_INSTANCE, data);
spiTransfer(HMC5883_SPI_INSTANCE, NULL, buf, 2); spiTransfer(HMC5883_SPI_INSTANCE, buf, NULL, 2);
DISABLE_HMC5883; DISABLE_HMC5883;
return true; 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) 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]; uint8_t in[2];
ENABLE_M25P16; ENABLE_M25P16;
spiTransfer(M25P16_SPI_INSTANCE, in, command, sizeof(command)); spiTransfer(M25P16_SPI_INSTANCE, command, in, sizeof(command));
DISABLE_M25P16; DISABLE_M25P16;
@ -137,26 +137,25 @@ bool m25p16_waitForReady(uint32_t timeoutMillis)
*/ */
static bool m25p16_readIdentification(void) static bool m25p16_readIdentification(void)
{ {
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 chipID;
delay(50); // short delay required after initialisation of SPI device instance. 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 /* Just in case transfer fails and writes nothing, so we don't try to verify the ID against random garbage
* from the stack: * from the stack:
*/ */
uint8_t in[4];
in[1] = 0; in[1] = 0;
ENABLE_M25P16; 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: // Clearing the CS bit terminates the command early so we don't have to read the chip UID:
DISABLE_M25P16; DISABLE_M25P16;
// Manufacturer, memory type, and capacity // 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 // 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) 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); m25p16_waitForReady(SECTOR_ERASE_TIMEOUT_MILLIS);
@ -249,7 +248,7 @@ void m25p16_eraseSector(uint32_t address)
ENABLE_M25P16; ENABLE_M25P16;
spiTransfer(M25P16_SPI_INSTANCE, NULL, out, sizeof(out)); spiTransfer(M25P16_SPI_INSTANCE, out, NULL, sizeof(out));
DISABLE_M25P16; DISABLE_M25P16;
} }
@ -265,7 +264,7 @@ void m25p16_eraseCompletely(void)
void m25p16_pageProgramBegin(uint32_t address) 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); m25p16_waitForReady(DEFAULT_TIMEOUT_MILLIS);
@ -273,12 +272,12 @@ void m25p16_pageProgramBegin(uint32_t address)
ENABLE_M25P16; 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) 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) 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) 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)) { if (!m25p16_waitForReady(DEFAULT_TIMEOUT_MILLIS)) {
return 0; return 0;
@ -328,8 +327,8 @@ int m25p16_readBytes(uint32_t address, uint8_t *buffer, int length)
ENABLE_M25P16; ENABLE_M25P16;
spiTransfer(M25P16_SPI_INSTANCE, NULL, command, sizeof(command)); spiTransfer(M25P16_SPI_INSTANCE, command, NULL, sizeof(command));
spiTransfer(M25P16_SPI_INSTANCE, buffer, NULL, length); spiTransfer(M25P16_SPI_INSTANCE, NULL, buffer, length);
DISABLE_M25P16; 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) static uint8_t sdcard_sendCommand(uint8_t commandCode, uint32_t commandArgument)
{ {
uint8_t command[6] = { const uint8_t command[6] = {
0x40 | commandCode, 0x40 | commandCode,
commandArgument >> 24, commandArgument >> 24,
commandArgument >> 16, 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) if (!sdcard_waitForIdle(SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY) && commandCode != SDCARD_COMMAND_GO_IDLE_STATE)
return 0xFF; 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 * 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 // V1 cards don't support this command
sdcard.version = 1; sdcard.version = 1;
} else if (status == SDCARD_R1_STATUS_BIT_IDLE) { } 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 * 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]; uint8_t response[4];
spiTransfer(SDCARD_SPI_INSTANCE, response, NULL, sizeof(response)); spiTransfer(SDCARD_SPI_INSTANCE, NULL, response, sizeof(response));
if (status == 0) { if (status == 0) {
sdcard_deselect(); sdcard_deselect();
@ -370,7 +370,7 @@ static sdcardReceiveBlockStatus_e sdcard_receiveDataBlock(uint8_t *buffer, int c
return SDCARD_RECEIVE_ERROR; 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 // Discard trailing CRC, we don't care
spiTransferByte(SDCARD_SPI_INSTANCE, 0xFF); 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. * 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: // Card wants 8 dummy clock cycles between the write command's response and a data block beginning:
spiTransferByte(SDCARD_SPI_INSTANCE, 0xFF); spiTransferByte(SDCARD_SPI_INSTANCE, 0xFF);
@ -455,7 +455,7 @@ static void sdcard_sendDataBlockBegin(uint8_t *buffer, bool multiBlockWrite)
} }
else { else {
// Send the first chunk now // 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 #endif
if (!useDMAForTx) { if (!useDMAForTx) {
// Send another chunk // 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++; 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)); nazeSpiCsPin = IOGetByTag(IO_TAG(NAZE_SPI_CS_PIN));
#endif #endif
uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0 }; const uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0 };
uint8_t in[4]; uint8_t in[4];
uint32_t flash_id; uint32_t flash_id;
// try autodetect flash chip // try autodetect flash chip
delay(50); // short delay required after initialisation of SPI device instance. delay(50); // short delay required after initialisation of SPI device instance.
ENABLE_SPI_CS; ENABLE_SPI_CS;
spiTransfer(NAZE_SPI_INSTANCE, in, out, sizeof(out)); spiTransfer(NAZE_SPI_INSTANCE, out, in, sizeof(out));
DISABLE_SPI_CS; DISABLE_SPI_CS;
flash_id = in[1] << 16 | in[2] << 8 | in[3]; 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" { 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); void bmp280_calculate(int32_t *pressure, int32_t *temperature);
extern uint32_t bmp280_up; extern uint32_t bmp280_up;
@ -139,22 +144,11 @@ TEST(baroBmp280Test, TestBmp280CalculateZeroP)
extern "C" { extern "C" {
void delay(uint32_t) {} 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() { void spiSetDivisor() {
} }

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

@ -18,6 +18,11 @@
extern "C" { extern "C" {
#include "platform.h"
#include "target.h"
#include "drivers/barometer/barometer.h"
#include "drivers/bus.h"
int8_t ms5611_crc(uint16_t *prom); int8_t ms5611_crc(uint16_t *prom);
void ms5611_calculate(int32_t *pressure, int32_t *temperature); void ms5611_calculate(int32_t *pressure, int32_t *temperature);
@ -141,21 +146,10 @@ extern "C" {
void delay(uint32_t) {} void delay(uint32_t) {}
void delayMicroseconds(uint32_t) {} void delayMicroseconds(uint32_t) {}
bool i2cWriteRegister(uint8_t, uint8_t, uint8_t) { bool i2cBusReadRegisterBuffer(busDevice_t*, uint8_t, uint8_t*, uint8_t) {return true;}
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 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() { void spiSetDivisor() {
} }