Mirror/inav
1
0
Fork 0
mirror of https://github.com/iNavFlight/inav.git synced 2025-07-23 08:15:26 +03:00
Code Issues Wiki Activity

First cut of conversion of SPI to new IO (#435)

Browse source
This commit is contained in:
Martin Budden 2016-08-08 15:36:43 +01:00 • committed by Konstantin Sharlaimov
parent ebebeb154f
commit b7bf34c4c4
34 changed files with 722 additions and 723 deletions
Download patch file Download diff file Expand all files Collapse all files

40
src/main/drivers/accgyro_l3gd20.c
View file

@ -25,7 +25,7 @@
#include "common/maths.h" #include "common/maths.h"
#include "system.h" #include "system.h"
#include "gpio.h" #include "io.h"
#include "bus_spi.h" #include "bus_spi.h"
#include "sensor.h" #include "sensor.h"
@ -66,24 +66,22 @@
#define BOOT ((uint8_t)0x80) #define BOOT ((uint8_t)0x80)
#define ENABLE_L3GD20 IOLo(mpul3gd20CsPin)
#define DISABLE_L3GD20 IOHi(mpul3gd20CsPin)
static IO_t mpul3gd20CsPin = IO_NONE;
static void l3gd20SpiInit(SPI_TypeDef *SPIx) static void l3gd20SpiInit(SPI_TypeDef *SPIx)
{ {
UNUSED(SPIx); // FIXME UNUSED(SPIx); // FIXME
GPIO_InitTypeDef GPIO_InitStructure;
RCC_AHBPeriphClockCmd(L3GD20_CS_GPIO_CLK_PERIPHERAL, ENABLE); mpul3gd20CsPin = IOGetByTag(IO_TAG(L3GD20_CS_PIN));
IOInit(mpul3gd20CsPin, OWNER_MPU, RESOURCE_SPI_CS, 0);
IOConfigGPIO(mpul3gd20CsPin, SPI_IO_CS_CFG);
GPIO_InitStructure.GPIO_Pin = L3GD20_CS_PIN; DISABLE_L3GD20;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(L3GD20_CS_GPIO, &GPIO_InitStructure); spiSetDivisor(L3GD20_SPI, SPI_CLOCK_STANDARD);
GPIO_SetBits(L3GD20_CS_GPIO, L3GD20_CS_PIN);
spiSetDivisor(L3GD20_SPI, SPI_9MHZ_CLOCK_DIVIDER);
} }
void l3gd20GyroInit(uint8_t lpf) void l3gd20GyroInit(uint8_t lpf)
@ -92,32 +90,32 @@ void l3gd20GyroInit(uint8_t lpf)
l3gd20SpiInit(L3GD20_SPI); l3gd20SpiInit(L3GD20_SPI);
GPIO_ResetBits(L3GD20_CS_GPIO, L3GD20_CS_PIN); ENABLE_L3GD20;
spiTransferByte(L3GD20_SPI, CTRL_REG5_ADDR); spiTransferByte(L3GD20_SPI, CTRL_REG5_ADDR);
spiTransferByte(L3GD20_SPI, BOOT); spiTransferByte(L3GD20_SPI, BOOT);
GPIO_SetBits(L3GD20_CS_GPIO, L3GD20_CS_PIN); DISABLE_L3GD20;
delayMicroseconds(100); delayMicroseconds(100);
GPIO_ResetBits(L3GD20_CS_GPIO, L3GD20_CS_PIN); ENABLE_L3GD20;
spiTransferByte(L3GD20_SPI, CTRL_REG1_ADDR); spiTransferByte(L3GD20_SPI, CTRL_REG1_ADDR);
spiTransferByte(L3GD20_SPI, MODE_ACTIVE | OUTPUT_DATARATE_3 | AXES_ENABLE | BANDWIDTH_3); spiTransferByte(L3GD20_SPI, MODE_ACTIVE | OUTPUT_DATARATE_3 | AXES_ENABLE | BANDWIDTH_3);
//spiTransferByte(L3GD20_SPI, MODE_ACTIVE | OUTPUT_DATARATE_4 | AXES_ENABLE | BANDWIDTH_4); //spiTransferByte(L3GD20_SPI, MODE_ACTIVE | OUTPUT_DATARATE_4 | AXES_ENABLE | BANDWIDTH_4);
GPIO_SetBits(L3GD20_CS_GPIO, L3GD20_CS_PIN); DISABLE_L3GD20;
delayMicroseconds(1); delayMicroseconds(1);
GPIO_ResetBits(L3GD20_CS_GPIO, L3GD20_CS_PIN); ENABLE_L3GD20;
spiTransferByte(L3GD20_SPI, CTRL_REG4_ADDR); spiTransferByte(L3GD20_SPI, CTRL_REG4_ADDR);
spiTransferByte(L3GD20_SPI, BLOCK_DATA_UPDATE_CONTINUOUS | BLE_MSB | FULLSCALE_2000); spiTransferByte(L3GD20_SPI, BLOCK_DATA_UPDATE_CONTINUOUS | BLE_MSB | FULLSCALE_2000);
GPIO_SetBits(L3GD20_CS_GPIO, L3GD20_CS_PIN); DISABLE_L3GD20;
delay(100); delay(100);
} }
@ -126,7 +124,7 @@ static bool l3gd20GyroRead(int16_t *gyroADC)
{ {
uint8_t buf[6]; uint8_t buf[6];
GPIO_ResetBits(L3GD20_CS_GPIO, L3GD20_CS_PIN); ENABLE_L3GD20;
spiTransferByte(L3GD20_SPI, OUT_X_L_ADDR | READ_CMD | MULTIPLEBYTE_CMD); spiTransferByte(L3GD20_SPI, OUT_X_L_ADDR | READ_CMD | MULTIPLEBYTE_CMD);
uint8_t index; uint8_t index;
@ -134,7 +132,7 @@ static bool l3gd20GyroRead(int16_t *gyroADC)
buf[index] = spiTransferByte(L3GD20_SPI, DUMMY_BYTE); buf[index] = spiTransferByte(L3GD20_SPI, DUMMY_BYTE);
} }
GPIO_SetBits(L3GD20_CS_GPIO, L3GD20_CS_PIN); DISABLE_L3GD20;
gyroADC[0] = (int16_t)((buf[0] << 8) | buf[1]); gyroADC[0] = (int16_t)((buf[0] << 8) | buf[1]);
gyroADC[1] = (int16_t)((buf[2] << 8) | buf[3]); gyroADC[1] = (int16_t)((buf[2] << 8) | buf[3]);

1
src/main/drivers/accgyro_lsm303dlhc.c
View file

@ -171,4 +171,3 @@ bool lsm303dlhcAccDetect(acc_t *acc)
return true; return true;
} }
#endif #endif

53
src/main/drivers/accgyro_spi_mpu6000.c
View file

@ -24,30 +24,32 @@
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h>
#include <platform.h> #include "platform.h"
#include "common/axis.h" #include "common/axis.h"
#include "common/maths.h" #include "common/maths.h"
#include "system.h" #include "system.h"
#include "gpio.h" #include "io.h"
#include "exti.h" #include "exti.h"
#include "bus_spi.h" #include "bus_spi.h"
#include "gyro_sync.h" #include "gyro_sync.h"
#include "sensor.h" #include "sensor.h"
#include "accgyro.h" #include "accgyro.h"
#include "accgyro_mpu.h" #include "accgyro_mpu.h"
#if defined(USE_GYRO_SPI_MPU6000) || defined(USE_ACC_SPI_MPU6000)
#include "accgyro_spi_mpu6000.h" #include "accgyro_spi_mpu6000.h"
static void mpu6000AccAndGyroInit(void); static void mpu6000AccAndGyroInit(void);
extern uint8_t mpuLowPassFilter;
static bool mpuSpi6000InitDone = false; static bool mpuSpi6000InitDone = false;
// Bits // Bits
#define BIT_SLEEP 0x40 #define BIT_SLEEP 0x40
#define BIT_H_RESET 0x80 #define BIT_H_RESET 0x80
@ -97,9 +99,10 @@ static bool mpuSpi6000InitDone = false;
#define MPU6000_REV_D9 0x59 #define MPU6000_REV_D9 0x59
#define MPU6000_REV_D10 0x5A #define MPU6000_REV_D10 0x5A
#define DISABLE_MPU6000 GPIO_SetBits(MPU6000_CS_GPIO, MPU6000_CS_PIN) #define DISABLE_MPU6000 IOHi(mpuSpi6000CsPin)
#define ENABLE_MPU6000 GPIO_ResetBits(MPU6000_CS_GPIO, MPU6000_CS_PIN) #define ENABLE_MPU6000 IOLo(mpuSpi6000CsPin)
static IO_t mpuSpi6000CsPin = IO_NONE;
bool mpu6000WriteRegister(uint8_t reg, uint8_t data) bool mpu6000WriteRegister(uint8_t reg, uint8_t data)
{ {
@ -127,12 +130,14 @@ void mpu6000SpiGyroInit(uint8_t lpf)
mpu6000AccAndGyroInit(); mpu6000AccAndGyroInit();
spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_0_5625MHZ_CLOCK_DIVIDER); spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_INITIALIZATON);
// Accel and Gyro DLPF Setting // Accel and Gyro DLPF Setting
mpu6000WriteRegister(MPU6000_CONFIG, lpf); mpu6000WriteRegister(MPU6000_CONFIG, lpf);
delayMicroseconds(1); delayMicroseconds(1);
spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_FAST); // 18 MHz SPI clock
int16_t data[3]; int16_t data[3];
mpuGyroRead(data); mpuGyroRead(data);
@ -153,7 +158,13 @@ bool mpu6000SpiDetect(void)
uint8_t in; uint8_t in;
uint8_t attemptsRemaining = 5; uint8_t attemptsRemaining = 5;
spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_0_5625MHZ_CLOCK_DIVIDER); #ifdef MPU6000_CS_PIN
mpuSpi6000CsPin = IOGetByTag(IO_TAG(MPU6000_CS_PIN));
#endif
IOInit(mpuSpi6000CsPin, OWNER_MPU, RESOURCE_SPI_CS, 0);
IOConfigGPIO(mpuSpi6000CsPin, SPI_IO_CS_CFG);
spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_INITIALIZATON);
mpu6000WriteRegister(MPU_RA_PWR_MGMT_1, BIT_H_RESET); mpu6000WriteRegister(MPU_RA_PWR_MGMT_1, BIT_H_RESET);
@ -201,7 +212,7 @@ static void mpu6000AccAndGyroInit(void)
return; return;
} }
spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_0_5625MHZ_CLOCK_DIVIDER); spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_INITIALIZATON);
// Device Reset // Device Reset
mpu6000WriteRegister(MPU_RA_PWR_MGMT_1, BIT_H_RESET); mpu6000WriteRegister(MPU_RA_PWR_MGMT_1, BIT_H_RESET);
@ -212,14 +223,14 @@ static void mpu6000AccAndGyroInit(void)
// Clock Source PPL with Z axis gyro reference // Clock Source PPL with Z axis gyro reference
mpu6000WriteRegister(MPU_RA_PWR_MGMT_1, MPU_CLK_SEL_PLLGYROZ); mpu6000WriteRegister(MPU_RA_PWR_MGMT_1, MPU_CLK_SEL_PLLGYROZ);
delayMicroseconds(1); delayMicroseconds(15);
// Disable Primary I2C Interface // Disable Primary I2C Interface
mpu6000WriteRegister(MPU_RA_USER_CTRL, BIT_I2C_IF_DIS); mpu6000WriteRegister(MPU_RA_USER_CTRL, BIT_I2C_IF_DIS);
delayMicroseconds(1); delayMicroseconds(15);
mpu6000WriteRegister(MPU_RA_PWR_MGMT_2, 0x00); mpu6000WriteRegister(MPU_RA_PWR_MGMT_2, 0x00);
delayMicroseconds(1); 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
@ -228,22 +239,23 @@ static void mpu6000AccAndGyroInit(void)
// Gyro +/- 1000 DPS Full Scale // Gyro +/- 1000 DPS Full Scale
mpu6000WriteRegister(MPU_RA_GYRO_CONFIG, INV_FSR_2000DPS << 3); mpu6000WriteRegister(MPU_RA_GYRO_CONFIG, INV_FSR_2000DPS << 3);
delayMicroseconds(1); delayMicroseconds(15);
// Accel +/- 8 G Full Scale // Accel +/- 8 G Full Scale
mpu6000WriteRegister(MPU_RA_ACCEL_CONFIG, INV_FSR_8G << 3); mpu6000WriteRegister(MPU_RA_ACCEL_CONFIG, INV_FSR_16G << 3);
delayMicroseconds(1); delayMicroseconds(15);
mpu6000WriteRegister(MPU_RA_INT_PIN_CFG, 0 << 7 | 0 << 6 | 0 << 5 | 1 << 4 | 0 << 3 | 0 << 2 | 0 << 1 | 0 << 0); // INT_ANYRD_2CLEAR mpu6000WriteRegister(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(1); delayMicroseconds(15);
#ifdef USE_MPU_DATA_READY_SIGNAL #ifdef USE_MPU_DATA_READY_SIGNAL
mpu6000WriteRegister(MPU_RA_INT_ENABLE, MPU_RF_DATA_RDY_EN); mpu6000WriteRegister(MPU_RA_INT_ENABLE, MPU_RF_DATA_RDY_EN);
delayMicroseconds(1); delayMicroseconds(15);
#endif #endif
spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_18MHZ_CLOCK_DIVIDER); // 18 MHz SPI clock spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_FAST);
delayMicroseconds(1);
mpuSpi6000InitDone = true; mpuSpi6000InitDone = true;
} }
@ -269,9 +281,10 @@ bool mpu6000SpiGyroDetect(gyro_t *gyro)
gyro->init = mpu6000SpiGyroInit; gyro->init = mpu6000SpiGyroInit;
gyro->read = mpuGyroRead; gyro->read = mpuGyroRead;
gyro->intStatus = checkMPUDataReady; gyro->intStatus = checkMPUDataReady;
// 16.4 dps/lsb scalefactor // 16.4 dps/lsb scalefactor
gyro->scale = 1.0f / 16.4f; gyro->scale = 1.0f / 16.4f;
return true; return true;
} }
#endif

44
src/main/drivers/accgyro_spi_mpu6500.c
View file

@ -26,7 +26,7 @@
#include "system.h" #include "system.h"
#include "exti.h" #include "exti.h"
#include "gpio.h" #include "io.h"
#include "bus_spi.h" #include "bus_spi.h"
#include "sensor.h" #include "sensor.h"
@ -35,8 +35,10 @@
#include "accgyro_mpu6500.h" #include "accgyro_mpu6500.h"
#include "accgyro_spi_mpu6500.h" #include "accgyro_spi_mpu6500.h"
#define DISABLE_MPU6500 GPIO_SetBits(MPU6500_CS_GPIO, MPU6500_CS_PIN) #define DISABLE_MPU6500 IOHi(mpuSpi6500CsPin)
#define ENABLE_MPU6500 GPIO_ResetBits(MPU6500_CS_GPIO, MPU6500_CS_PIN) #define ENABLE_MPU6500 IOLo(mpuSpi6500CsPin)
static IO_t mpuSpi6500CsPin = IO_NONE;
bool mpu6500WriteRegister(uint8_t reg, uint8_t data) bool mpu6500WriteRegister(uint8_t reg, uint8_t data)
{ {
@ -66,46 +68,24 @@ static void mpu6500SpiInit(void)
return; return;
} }
#ifdef STM32F303xC mpuSpi6500CsPin = IOGetByTag(IO_TAG(MPU6500_CS_PIN));
RCC_AHBPeriphClockCmd(MPU6500_CS_GPIO_CLK_PERIPHERAL, ENABLE); IOInit(mpuSpi6500CsPin, OWNER_MPU, RESOURCE_SPI_CS, 0);
IOConfigGPIO(mpuSpi6500CsPin, SPI_IO_CS_CFG);
GPIO_InitTypeDef GPIO_InitStructure; spiSetDivisor(MPU6500_SPI_INSTANCE, SPI_CLOCK_FAST);
GPIO_InitStructure.GPIO_Pin = MPU6500_CS_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(MPU6500_CS_GPIO, &GPIO_InitStructure);
#endif
#ifdef STM32F10X
RCC_APB2PeriphClockCmd(MPU6500_CS_GPIO_CLK_PERIPHERAL, ENABLE);
gpio_config_t gpio;
// CS as output
gpio.mode = Mode_Out_PP;
gpio.pin = MPU6500_CS_PIN;
gpio.speed = Speed_50MHz;
gpioInit(MPU6500_CS_GPIO, &gpio);
#endif
GPIO_SetBits(MPU6500_CS_GPIO, MPU6500_CS_PIN);
spiSetDivisor(MPU6500_SPI_INSTANCE, SPI_9MHZ_CLOCK_DIVIDER);
hardwareInitialised = true; hardwareInitialised = true;
} }
bool mpu6500SpiDetect(void) bool mpu6500SpiDetect(void)
{ {
uint8_t sig; uint8_t tmp;
mpu6500SpiInit(); mpu6500SpiInit();
mpu6500ReadRegister(MPU_RA_WHO_AM_I, 1, &sig); mpu6500ReadRegister(MPU_RA_WHO_AM_I, 1, &tmp);
if (sig == MPU6500_WHO_AM_I_CONST || sig == MPU9250_WHO_AM_I_CONST) { if (tmp == MPU6500_WHO_AM_I_CONST || tmp == MPU9250_WHO_AM_I_CONST || tmp == ICM20608G_WHO_AM_I_CONST) {
return true; return true;
} }

539
src/main/drivers/bus_spi.c
View file

@ -20,336 +20,222 @@
#include <platform.h> #include <platform.h>
#include "build_config.h"
#include "gpio.h"
#include "bus_spi.h" #include "bus_spi.h"
#include "exti.h"
#include "io.h"
#include "io_impl.h"
#include "rcc.h"
#ifdef USE_SPI_DEVICE_1 /* for F30x processors */
#if defined(STM32F303xC)
#ifndef SPI1_GPIO #ifndef GPIO_AF_SPI1
#define SPI1_GPIO GPIOA #define GPIO_AF_SPI1 GPIO_AF_5
#define SPI1_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOA #endif
#define SPI1_NSS_PIN GPIO_Pin_4 #ifndef GPIO_AF_SPI2
#define SPI1_NSS_PIN_SOURCE GPIO_PinSource4 #define GPIO_AF_SPI2 GPIO_AF_5
#define SPI1_SCK_PIN GPIO_Pin_5 #endif
#define SPI1_SCK_PIN_SOURCE GPIO_PinSource5 #ifndef GPIO_AF_SPI3
#define SPI1_MISO_PIN GPIO_Pin_6 #define GPIO_AF_SPI3 GPIO_AF_6
#define SPI1_MISO_PIN_SOURCE GPIO_PinSource6 #endif
#define SPI1_MOSI_PIN GPIO_Pin_7
#define SPI1_MOSI_PIN_SOURCE GPIO_PinSource7
#endif #endif
void initSpi1(void) #ifndef SPI1_SCK_PIN
#define SPI1_NSS_PIN PA4
#define SPI1_SCK_PIN PA5
#define SPI1_MISO_PIN PA6
#define SPI1_MOSI_PIN PA7
#endif
#ifndef SPI2_SCK_PIN
#define SPI2_NSS_PIN PB12
#define SPI2_SCK_PIN PB13
#define SPI2_MISO_PIN PB14
#define SPI2_MOSI_PIN PB15
#endif
#ifndef SPI3_SCK_PIN
#define SPI3_NSS_PIN PA15
#define SPI3_SCK_PIN PB3
#define SPI3_MISO_PIN PB4
#define SPI3_MOSI_PIN PB5
#endif
#ifndef SPI1_NSS_PIN
#define SPI1_NSS_PIN NONE
#endif
#ifndef SPI2_NSS_PIN
#define SPI2_NSS_PIN NONE
#endif
#ifndef SPI3_NSS_PIN
#define SPI3_NSS_PIN NONE
#endif
static spiDevice_t spiHardwareMap[] = {
#if defined(STM32F1)
{ .dev = SPI1, .nss = IO_TAG(SPI1_NSS_PIN), .sck = IO_TAG(SPI1_SCK_PIN), .miso = IO_TAG(SPI1_MISO_PIN), .mosi = IO_TAG(SPI1_MOSI_PIN), .rcc = RCC_APB2(SPI1), .af = 0, false },
{ .dev = SPI2, .nss = IO_TAG(SPI2_NSS_PIN), .sck = IO_TAG(SPI2_SCK_PIN), .miso = IO_TAG(SPI2_MISO_PIN), .mosi = IO_TAG(SPI2_MOSI_PIN), .rcc = RCC_APB1(SPI2), .af = 0, false },
#else
{ .dev = SPI1, .nss = IO_TAG(SPI1_NSS_PIN), .sck = IO_TAG(SPI1_SCK_PIN), .miso = IO_TAG(SPI1_MISO_PIN), .mosi = IO_TAG(SPI1_MOSI_PIN), .rcc = RCC_APB2(SPI1), .af = GPIO_AF_SPI1, false },
{ .dev = SPI2, .nss = IO_TAG(SPI2_NSS_PIN), .sck = IO_TAG(SPI2_SCK_PIN), .miso = IO_TAG(SPI2_MISO_PIN), .mosi = IO_TAG(SPI2_MOSI_PIN), .rcc = RCC_APB1(SPI2), .af = GPIO_AF_SPI2, false },
#endif
#if defined(STM32F3) || defined(STM32F4)
{ .dev = SPI3, .nss = IO_TAG(SPI3_NSS_PIN), .sck = IO_TAG(SPI3_SCK_PIN), .miso = IO_TAG(SPI3_MISO_PIN), .mosi = IO_TAG(SPI3_MOSI_PIN), .rcc = RCC_APB1(SPI3), .af = GPIO_AF_SPI3, false }
#endif
};
SPIDevice spiDeviceByInstance(SPI_TypeDef *instance)
{ {
// Specific to the STM32F103 if (instance == SPI1)
// SPI1 Driver return SPIDEV_1;
// PA4 14 SPI1_NSS
// PA5 15 SPI1_SCK
// PA6 16 SPI1_MISO
// PA7 17 SPI1_MOSI
SPI_InitTypeDef spi; if (instance == SPI2)
return SPIDEV_2;
// Enable SPI1 clock if (instance == SPI3)
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE); return SPIDEV_3;
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1, ENABLE);
#ifdef STM32F303xC return SPIINVALID;
GPIO_InitTypeDef GPIO_InitStructure; }
RCC_AHBPeriphClockCmd(SPI1_GPIO_PERIPHERAL, ENABLE); void spiInitDevice(SPIDevice device)
{
SPI_InitTypeDef spiInit;
GPIO_PinAFConfig(SPI1_GPIO, SPI1_SCK_PIN_SOURCE, GPIO_AF_5); spiDevice_t *spi = &(spiHardwareMap[device]);
GPIO_PinAFConfig(SPI1_GPIO, SPI1_MISO_PIN_SOURCE, GPIO_AF_5);
GPIO_PinAFConfig(SPI1_GPIO, SPI1_MOSI_PIN_SOURCE, GPIO_AF_5);
#ifdef SPI1_NSS_PIN_SOURCE #ifdef SDCARD_SPI_INSTANCE
GPIO_PinAFConfig(SPI1_GPIO, SPI1_NSS_PIN_SOURCE, GPIO_AF_5); if (spi->dev == SDCARD_SPI_INSTANCE) {
spi->sdcard = true;
}
#endif
#ifdef NRF24_SPI_INSTANCE
if (spi->dev == NRF24_SPI_INSTANCE) {
spi->nrf24l01 = true;
}
#endif #endif
// Init pins // Enable SPI clock
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF; RCC_ClockCmd(spi->rcc, ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; RCC_ResetCmd(spi->rcc, ENABLE);
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
#ifdef USE_SDCARD_SPI1 IOInit(IOGetByTag(spi->sck), OWNER_SPI, RESOURCE_SPI_SCK, device + 1);
// Configure pins and pullups for SD-card use IOInit(IOGetByTag(spi->miso), OWNER_SPI, RESOURCE_SPI_MISO, device + 1);
IOInit(IOGetByTag(spi->mosi), OWNER_SPI, RESOURCE_SPI_MOSI, device + 1);
// No pull-up needed since we drive this pin as an output #if defined(STM32F3) || defined(STM32F4)
GPIO_InitStructure.GPIO_Pin = SPI1_MOSI_PIN; IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_CFG, spi->af);
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_CFG, spi->af);
GPIO_Init(SPI1_GPIO, &GPIO_InitStructure); IOConfigGPIOAF(IOGetByTag(spi->mosi), SPI_IO_AF_CFG, spi->af);
// Prevent MISO pin from floating when SDCard is deselected (high-Z) or not connected if (spi->nss) {
GPIO_InitStructure.GPIO_Pin = SPI1_MISO_PIN; IOConfigGPIOAF(IOGetByTag(spi->nss), SPI_IO_CS_CFG, spi->af);
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; }
GPIO_Init(SPI1_GPIO, &GPIO_InitStructure); #endif
#if defined(STM32F10X)
IOConfigGPIO(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG);
IOConfigGPIO(IOGetByTag(spi->miso), SPI_IO_AF_MISO_CFG);
IOConfigGPIO(IOGetByTag(spi->mosi), SPI_IO_AF_MOSI_CFG);
// In clock-low mode, STM32 manual says we should enable a pulldown to match if (spi->nss) {
GPIO_InitStructure.GPIO_Pin = SPI1_SCK_PIN; IOConfigGPIO(IOGetByTag(spi->nss), SPI_IO_CS_CFG);
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; }
GPIO_Init(SPI1_GPIO, &GPIO_InitStructure);
#else
// General-purpose pin config
GPIO_InitStructure.GPIO_Pin = SPI1_SCK_PIN | SPI1_MISO_PIN | SPI1_MOSI_PIN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(SPI1_GPIO, &GPIO_InitStructure);
#endif #endif
#ifdef SPI1_NSS_PIN // Init SPI hardware
GPIO_InitStructure.GPIO_Pin = SPI1_NSS_PIN; SPI_I2S_DeInit(spi->dev);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(SPI1_GPIO, &GPIO_InitStructure); spiInit.SPI_Mode = SPI_Mode_Master;
#endif spiInit.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
#endif spiInit.SPI_DataSize = SPI_DataSize_8b;
spiInit.SPI_NSS = SPI_NSS_Soft;
spiInit.SPI_FirstBit = SPI_FirstBit_MSB;
spiInit.SPI_CRCPolynomial = 7;
spiInit.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
#ifdef STM32F10X if (spi->sdcard || spi->nrf24l01) {
gpio_config_t gpio; spiInit.SPI_CPOL = SPI_CPOL_Low;
spiInit.SPI_CPHA = SPI_CPHA_1Edge;
// MOSI + SCK as output } else {
gpio.mode = Mode_AF_PP; spiInit.SPI_CPOL = SPI_CPOL_High;
gpio.pin = SPI1_MOSI_PIN | SPI1_SCK_PIN; spiInit.SPI_CPHA = SPI_CPHA_2Edge;
gpio.speed = Speed_50MHz; }
gpioInit(SPI1_GPIO, &gpio);
// MISO as input
gpio.pin = SPI1_MISO_PIN;
gpio.mode = Mode_IN_FLOATING;
gpioInit(SPI1_GPIO, &gpio);
#ifdef SPI1_NSS_PIN
// NSS as gpio slave select
gpio.pin = SPI1_NSS_PIN;
gpio.mode = Mode_Out_PP;
gpioInit(SPI1_GPIO, &gpio);
#endif
#endif
// Init SPI1 hardware
SPI_I2S_DeInit(SPI1);
spi.SPI_Mode = SPI_Mode_Master;
spi.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
spi.SPI_DataSize = SPI_DataSize_8b;
spi.SPI_NSS = SPI_NSS_Soft;
spi.SPI_FirstBit = SPI_FirstBit_MSB;
spi.SPI_CRCPolynomial = 7;
spi.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
#if (defined(USE_SDCARD_SPI1) || defined(USE_NRF24_SPI1))
spi.SPI_CPOL = SPI_CPOL_Low;
spi.SPI_CPHA = SPI_CPHA_1Edge;
#else
spi.SPI_CPOL = SPI_CPOL_High;
spi.SPI_CPHA = SPI_CPHA_2Edge;
#endif
#ifdef STM32F303xC #ifdef STM32F303xC
// Configure for 8-bit reads. // Configure for 8-bit reads.
SPI_RxFIFOThresholdConfig(SPI1, SPI_RxFIFOThreshold_QF); SPI_RxFIFOThresholdConfig(spi->dev, SPI_RxFIFOThreshold_QF);
#endif #endif
SPI_Init(SPI1, &spi); SPI_Init(spi->dev, &spiInit);
SPI_Cmd(SPI1, ENABLE); SPI_Cmd(spi->dev, ENABLE);
#ifdef SPI1_NSS_PIN if (spi->nss) {
// Drive NSS high to disable connected SPI device. // Drive NSS high to disable connected SPI device.
GPIO_SetBits(SPI1_GPIO, SPI1_NSS_PIN); IOHi(IOGetByTag(spi->nss));
#endif }
} }
#endif
#ifdef USE_SPI_DEVICE_2 bool spiInit(SPIDevice device)
#ifndef SPI2_GPIO
#define SPI2_GPIO GPIOB
#define SPI2_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB
#define SPI2_NSS_PIN GPIO_Pin_12
#define SPI2_NSS_PIN_SOURCE GPIO_PinSource12
#define SPI2_SCK_PIN GPIO_Pin_13
#define SPI2_SCK_PIN_SOURCE GPIO_PinSource13
#define SPI2_MISO_PIN GPIO_Pin_14
#define SPI2_MISO_PIN_SOURCE GPIO_PinSource14
#define SPI2_MOSI_PIN GPIO_Pin_15
#define SPI2_MOSI_PIN_SOURCE GPIO_PinSource15
#endif
void initSpi2(void)
{ {
// Specific to the STM32F103 / STM32F303 (AF5) switch (device)
// SPI2 Driver {
// PB12 25 SPI2_NSS case SPIINVALID:
// PB13 26 SPI2_SCK return false;
// PB14 27 SPI2_MISO case SPIDEV_1:
// PB15 28 SPI2_MOSI
SPI_InitTypeDef spi;
// Enable SPI2 clock
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2, ENABLE);
#ifdef STM32F303xC
GPIO_InitTypeDef GPIO_InitStructure;
RCC_AHBPeriphClockCmd(SPI2_GPIO_PERIPHERAL, ENABLE);
GPIO_PinAFConfig(SPI2_GPIO, SPI2_SCK_PIN_SOURCE, GPIO_AF_5);
GPIO_PinAFConfig(SPI2_GPIO, SPI2_MISO_PIN_SOURCE, GPIO_AF_5);
GPIO_PinAFConfig(SPI2_GPIO, SPI2_MOSI_PIN_SOURCE, GPIO_AF_5);
#ifdef SPI2_NSS_PIN_SOURCE
GPIO_PinAFConfig(SPI2_GPIO, SPI2_NSS_PIN_SOURCE, GPIO_AF_5);
#endif
// Init pins
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
#ifdef USE_SDCARD_SPI2
// Configure pins and pullups for SD-card use
// No pull-up needed since we drive this pin as an output
GPIO_InitStructure.GPIO_Pin = SPI2_MOSI_PIN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(SPI2_GPIO, &GPIO_InitStructure);
// Prevent MISO pin from floating when SDCard is deselected (high-Z) or not connected
GPIO_InitStructure.GPIO_Pin = SPI2_MISO_PIN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(SPI2_GPIO, &GPIO_InitStructure);
// In clock-low mode, STM32 manual says we should enable a pulldown to match
GPIO_InitStructure.GPIO_Pin = SPI2_SCK_PIN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_Init(SPI2_GPIO, &GPIO_InitStructure);
#else
// General-purpose pin config
GPIO_InitStructure.GPIO_Pin = SPI2_SCK_PIN | SPI2_MISO_PIN | SPI2_MOSI_PIN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(SPI2_GPIO, &GPIO_InitStructure);
#endif
#ifdef SPI2_NSS_PIN
GPIO_InitStructure.GPIO_Pin = SPI2_NSS_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(SPI2_GPIO, &GPIO_InitStructure);
#endif
#endif
#ifdef STM32F10X
gpio_config_t gpio;
// MOSI + SCK as output
gpio.mode = Mode_AF_PP;
gpio.pin = SPI2_SCK_PIN | SPI2_MOSI_PIN;
gpio.speed = Speed_50MHz;
gpioInit(SPI2_GPIO, &gpio);
// MISO as input
gpio.pin = SPI2_MISO_PIN;
gpio.mode = Mode_IN_FLOATING;
gpioInit(SPI2_GPIO, &gpio);
#ifdef SPI2_NSS_PIN
// NSS as gpio slave select
gpio.pin = SPI2_NSS_PIN;
gpio.mode = Mode_Out_PP;
gpioInit(SPI2_GPIO, &gpio);
#endif
#endif
// Init SPI2 hardware
SPI_I2S_DeInit(SPI2);
spi.SPI_Mode = SPI_Mode_Master;
spi.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
spi.SPI_DataSize = SPI_DataSize_8b;
spi.SPI_NSS = SPI_NSS_Soft;
spi.SPI_FirstBit = SPI_FirstBit_MSB;
spi.SPI_CRCPolynomial = 7;
spi.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
#ifdef USE_SDCARD_SPI2
spi.SPI_CPOL = SPI_CPOL_Low;
spi.SPI_CPHA = SPI_CPHA_1Edge;
#else
spi.SPI_CPOL = SPI_CPOL_High;
spi.SPI_CPHA = SPI_CPHA_2Edge;
#endif
#ifdef STM32F303xC
// Configure for 8-bit reads.
SPI_RxFIFOThresholdConfig(SPI2, SPI_RxFIFOThreshold_QF);
#endif
SPI_Init(SPI2, &spi);
SPI_Cmd(SPI2, ENABLE);
#ifdef SPI2_NSS_PIN
// Drive NSS high to disable connected SPI device.
GPIO_SetBits(SPI2_GPIO, SPI2_NSS_PIN);
#endif
}
#endif
bool spiInit(SPI_TypeDef *instance)
{
#if (!(defined(USE_SPI_DEVICE_1) && defined(USE_SPI_DEVICE_2)))
UNUSED(instance);
#endif
#ifdef USE_SPI_DEVICE_1 #ifdef USE_SPI_DEVICE_1
if (instance == SPI1) { spiInitDevice(device);
initSpi1();
return true; return true;
} #else
break;
#endif #endif
case SPIDEV_2:
#ifdef USE_SPI_DEVICE_2 #ifdef USE_SPI_DEVICE_2
if (instance == SPI2) { spiInitDevice(device);
initSpi2();
return true; return true;
} #else
break;
#endif #endif
case SPIDEV_3:
#if defined(USE_SPI_DEVICE_3) && (defined(STM32F303xC) || defined(STM32F4))
spiInitDevice(device);
return true;
#else
break;
#endif
}
return false; return false;
} }
uint32_t spiTimeoutUserCallback(SPI_TypeDef *instance)
{
SPIDevice device = spiDeviceByInstance(instance);
if (device == SPIINVALID)
return -1;
spiHardwareMap[device].errorCount++;
return spiHardwareMap[device].errorCount;
}
// return uint8_t value or -1 when failure
uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t data) uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t data)
{ {
uint16_t spiTimeout = 1000; uint16_t spiTimeout = 1000;
while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) { while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET)
if ((spiTimeout--) == 0) if ((spiTimeout--) == 0)
break; return spiTimeoutUserCallback(instance);
}
#ifdef STM32F303xC #ifdef STM32F303xC
SPI_SendData8(instance, data); SPI_SendData8(instance, data);
#endif #else
#ifdef STM32F10X
SPI_I2S_SendData(instance, data); SPI_I2S_SendData(instance, data);
#endif #endif
spiTimeout = 1000; spiTimeout = 1000;
while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET){ while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET)
if ((spiTimeout--) == 0) if ((spiTimeout--) == 0)
break; return spiTimeoutUserCallback(instance);
}
#ifdef STM32F303xC #ifdef STM32F303xC
return ((uint8_t)SPI_ReceiveData8(instance)); return ((uint8_t)SPI_ReceiveData8(instance));
#endif #else
#ifdef STM32F10X
return ((uint8_t)SPI_I2S_ReceiveData(instance)); return ((uint8_t)SPI_I2S_ReceiveData(instance));
#endif #endif
} }
@ -361,14 +247,13 @@ bool spiIsBusBusy(SPI_TypeDef *instance)
{ {
#ifdef STM32F303xC #ifdef STM32F303xC
return SPI_GetTransmissionFIFOStatus(instance) != SPI_TransmissionFIFOStatus_Empty || SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_BSY) == SET; return SPI_GetTransmissionFIFOStatus(instance) != SPI_TransmissionFIFOStatus_Empty || SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_BSY) == SET;
#endif #else
#ifdef STM32F10X
return SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET || SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_BSY) == SET; return SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET || SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_BSY) == SET;
#endif #endif
} }
void spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len) bool spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len)
{ {
uint16_t spiTimeout = 1000; uint16_t spiTimeout = 1000;
@ -378,32 +263,29 @@ void spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len
b = in ? *(in++) : 0xFF; b = in ? *(in++) : 0xFF;
while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) { while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) {
if ((spiTimeout--) == 0) if ((spiTimeout--) == 0)
break; return spiTimeoutUserCallback(instance);
} }
#ifdef STM32F303xC #ifdef STM32F303xC
SPI_SendData8(instance, b); SPI_SendData8(instance, b);
//SPI_I2S_SendData16(instance, b); #else
#endif
#ifdef STM32F10X
SPI_I2S_SendData(instance, b); SPI_I2S_SendData(instance, b);
#endif #endif
spiTimeout = 1000; spiTimeout = 1000;
while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET) { while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET) {
if ((spiTimeout--) == 0) if ((spiTimeout--) == 0)
break; return spiTimeoutUserCallback(instance);
} }
#ifdef STM32F303xC #ifdef STM32F303xC
b = SPI_ReceiveData8(instance); b = SPI_ReceiveData8(instance);
//b = SPI_I2S_ReceiveData16(instance); #else
#endif
#ifdef STM32F10X
b = SPI_I2S_ReceiveData(instance); b = SPI_I2S_ReceiveData(instance);
#endif #endif
if (out) if (out)
*(out++) = b; *(out++) = b;
} }
}
return true;
}
void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor) void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor)
{ {
@ -416,48 +298,63 @@ void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor)
tempRegister = instance->CR1; tempRegister = instance->CR1;
switch (divisor) { switch (divisor) {
case 2: case 2:
tempRegister &= BR_CLEAR_MASK; tempRegister &= BR_CLEAR_MASK;
tempRegister |= SPI_BaudRatePrescaler_2; tempRegister |= SPI_BaudRatePrescaler_2;
break; break;
case 4: case 4:
tempRegister &= BR_CLEAR_MASK; tempRegister &= BR_CLEAR_MASK;
tempRegister |= SPI_BaudRatePrescaler_4; tempRegister |= SPI_BaudRatePrescaler_4;
break; break;
case 8: case 8:
tempRegister &= BR_CLEAR_MASK; tempRegister &= BR_CLEAR_MASK;
tempRegister |= SPI_BaudRatePrescaler_8; tempRegister |= SPI_BaudRatePrescaler_8;
break; break;
case 16: case 16:
tempRegister &= BR_CLEAR_MASK; tempRegister &= BR_CLEAR_MASK;
tempRegister |= SPI_BaudRatePrescaler_16; tempRegister |= SPI_BaudRatePrescaler_16;
break; break;
case 32: case 32:
tempRegister &= BR_CLEAR_MASK; tempRegister &= BR_CLEAR_MASK;
tempRegister |= SPI_BaudRatePrescaler_32; tempRegister |= SPI_BaudRatePrescaler_32;
break; break;
case 64: case 64:
tempRegister &= BR_CLEAR_MASK; tempRegister &= BR_CLEAR_MASK;
tempRegister |= SPI_BaudRatePrescaler_64; tempRegister |= SPI_BaudRatePrescaler_64;
break; break;
case 128: case 128:
tempRegister &= BR_CLEAR_MASK; tempRegister &= BR_CLEAR_MASK;
tempRegister |= SPI_BaudRatePrescaler_128; tempRegister |= SPI_BaudRatePrescaler_128;
break; break;
case 256: case 256:
tempRegister &= BR_CLEAR_MASK; tempRegister &= BR_CLEAR_MASK;
tempRegister |= SPI_BaudRatePrescaler_256; tempRegister |= SPI_BaudRatePrescaler_256;
break; break;
} }
instance->CR1 = tempRegister; instance->CR1 = tempRegister;
SPI_Cmd(instance, ENABLE); SPI_Cmd(instance, ENABLE);
} }
uint16_t spiGetErrorCounter(SPI_TypeDef *instance)
{
SPIDevice device = spiDeviceByInstance(instance);
if (device == SPIINVALID)
return 0;
return spiHardwareMap[device].errorCount;
}
void spiResetErrorCounter(SPI_TypeDef *instance)
{
SPIDevice device = spiDeviceByInstance(instance);
if (device != SPIINVALID)
spiHardwareMap[device].errorCount = 0;
}

66
src/main/drivers/bus_spi.h
View file

@ -17,14 +17,68 @@
#pragma once #pragma once
#define SPI_0_28125MHZ_CLOCK_DIVIDER 256 #include "io_types.h"
#define SPI_0_5625MHZ_CLOCK_DIVIDER 128 #include "rcc_types.h"
#define SPI_18MHZ_CLOCK_DIVIDER 2
#define SPI_9MHZ_CLOCK_DIVIDER 4
bool spiInit(SPI_TypeDef *instance); #if defined(STM32F4) || defined(STM32F3)
#define SPI_IO_AF_CFG IO_CONFIG(GPIO_Mode_AF, GPIO_Speed_50MHz, GPIO_OType_PP, GPIO_PuPd_NOPULL)
#define SPI_IO_AF_SCK_CFG IO_CONFIG(GPIO_Mode_AF, GPIO_Speed_50MHz, GPIO_OType_PP, GPIO_PuPd_DOWN)
#define SPI_IO_AF_MISO_CFG IO_CONFIG(GPIO_Mode_AF, GPIO_Speed_50MHz, GPIO_OType_PP, GPIO_PuPd_UP)
#define SPI_IO_CS_CFG IO_CONFIG(GPIO_Mode_OUT, GPIO_Speed_50MHz, GPIO_OType_PP, GPIO_PuPd_NOPULL)
#elif defined(STM32F1)
#define SPI_IO_AF_SCK_CFG IO_CONFIG(GPIO_Mode_AF_PP, GPIO_Speed_50MHz)
#define SPI_IO_AF_MOSI_CFG IO_CONFIG(GPIO_Mode_AF_PP, GPIO_Speed_50MHz)
#define SPI_IO_AF_MISO_CFG IO_CONFIG(GPIO_Mode_IN_FLOATING, GPIO_Speed_50MHz)
#define SPI_IO_CS_CFG IO_CONFIG(GPIO_Mode_Out_PP, GPIO_Speed_50MHz)
#endif
/*
Flash M25p16 tolerates 20mhz, SPI_CLOCK_FAST should sit around 20 or less.
*/
typedef enum {
SPI_CLOCK_INITIALIZATON = 256,
#if defined(STM32F4)
SPI_CLOCK_SLOW = 128, //00.65625 MHz
SPI_CLOCK_STANDARD = 8, //10.50000 MHz
SPI_CLOCK_FAST = 4, //21.00000 MHz
SPI_CLOCK_ULTRAFAST = 2, //42.00000 MHz
#else
SPI_CLOCK_SLOW = 128, //00.56250 MHz
SPI_CLOCK_STANDARD = 4, //09.00000 MHz
SPI_CLOCK_FAST = 2, //18.00000 MHz
SPI_CLOCK_ULTRAFAST = 2, //18.00000 MHz
#endif
} SPIClockDivider_e;
typedef enum SPIDevice {
SPIINVALID = -1,
SPIDEV_1 = 0,
SPIDEV_2,
SPIDEV_3,
SPIDEV_MAX = SPIDEV_3,
} SPIDevice;
typedef struct SPIDevice_s {
SPI_TypeDef *dev;
ioTag_t nss;
ioTag_t sck;
ioTag_t mosi;
ioTag_t miso;
rccPeriphTag_t rcc;
uint8_t af;
volatile uint16_t errorCount;
bool sdcard;
bool nrf24l01;
} spiDevice_t;
bool spiInit(SPIDevice device);
void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor); void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor);
uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t in); uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t in);
bool spiIsBusBusy(SPI_TypeDef *instance); bool spiIsBusBusy(SPI_TypeDef *instance);
void spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len); bool spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len);
uint16_t spiGetErrorCounter(SPI_TypeDef *instance);
void spiResetErrorCounter(SPI_TypeDef *instance);
SPIDevice spiDeviceByInstance(SPI_TypeDef *instance);

68
src/main/drivers/bus_spi_soft.c
View file

@ -20,53 +20,67 @@
#include <platform.h> #include <platform.h>
#include "build_config.h"
#ifdef USE_SOFTSPI #ifdef USE_SOFTSPI
#include "gpio.h" #include "build_config.h"
#include "io.h"
#include "io_impl.h"
#include "bus_spi.h"
#include "bus_spi_soft.h" #include "bus_spi_soft.h"
void softSpiInit(const softSPIDevice_t *dev) void softSpiInit(const softSPIDevice_t *dev)
{ {
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
// SCK as output // SCK as output
GPIO_InitStructure.GPIO_Pin = dev->sck_pin; IOInit(IOGetByTag(dev->sckTag), OWNER_SOFTSPI, RESOURCE_SPI_SCK, SOFT_SPIDEV_1 + 1);
GPIO_Init(dev->sck_gpio, &GPIO_InitStructure); #if defined(STM32F10X)
// MOSI as output IOConfigGPIO(IOGetByTag(dev->sckTag), IO_CONFIG(GPIO_Mode_Out_PP, GPIO_Speed_50MHz));
GPIO_InitStructure.GPIO_Pin = dev->mosi_pin; #elif defined(STM32F3) || defined(STM32F4)
GPIO_Init(dev->mosi_gpio, &GPIO_InitStructure); IOConfigGPIOAF(IOGetByTag(dev->sckTag), SPI_IO_AF_CFG, 0);
// MISO as input
GPIO_InitStructure.GPIO_Pin = dev->miso_pin;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(dev->miso_gpio, &GPIO_InitStructure);
#ifdef SOFTSPI_NSS_PIN
// NSS as output
GPIO_InitStructure.GPIO_Pin = dev->nss_pin;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(dev->nss_gpio, &GPIO_InitStructure);
#endif #endif
// MOSI as output
IOInit(IOGetByTag(dev->mosiTag), OWNER_SOFTSPI, RESOURCE_SPI_MOSI, SOFT_SPIDEV_1 + 1);
#if defined(STM32F10X)
IOConfigGPIO(IOGetByTag(dev->mosiTag), IO_CONFIG(GPIO_Mode_Out_PP, GPIO_Speed_50MHz));
#elif defined(STM32F3) || defined(STM32F4)
IOConfigGPIOAF(IOGetByTag(dev->mosiTag), SPI_IO_AF_CFG, 0);
#endif
// MISO as input
IOInit(IOGetByTag(dev->misoTag), OWNER_SOFTSPI, RESOURCE_SPI_MISO, SOFT_SPIDEV_1 + 1);
#if defined(STM32F10X)
IOConfigGPIO(IOGetByTag(dev->misoTag), IO_CONFIG(GPIO_Mode_IN_FLOATING, GPIO_Speed_50MHz));
#elif defined(STM32F3) || defined(STM32F4)
IOConfigGPIOAF(IOGetByTag(dev->misoTag), SPI_IO_AF_CFG, 0);
#endif
// NSS as output
if (dev->nssTag != IOTAG_NONE) {
IOInit(IOGetByTag(dev->nssTag), OWNER_SOFTSPI, RESOURCE_SPI_CS, SOFT_SPIDEV_1 + 1);
#if defined(STM32F10X)
IOConfigGPIO(IOGetByTag(dev->nssTag), IO_CONFIG(GPIO_Mode_Out_PP, GPIO_Speed_50MHz));
#elif defined(STM32F3) || defined(STM32F4)
IOConfigGPIOAF(IOGetByTag(dev->nssTag), SPI_IO_AF_CFG, 0);
#endif
}
} }
uint8_t softSpiTransferByte(const softSPIDevice_t *dev, uint8_t byte) uint8_t softSpiTransferByte(const softSPIDevice_t *dev, uint8_t byte)
{ {
for(int ii = 0; ii < 8; ++ii) { for(int ii = 0; ii < 8; ++ii) {
if (byte & 0x80) { if (byte & 0x80) {
GPIO_SetBits(dev->mosi_gpio, dev->mosi_pin); IOHi(IOGetByTag(dev->mosiTag));
} else { } else {
GPIO_ResetBits(dev->mosi_gpio, dev->mosi_pin); IOLo(IOGetByTag(dev->mosiTag));
} }
GPIO_SetBits(dev->sck_gpio, dev->sck_pin); IOHi(IOGetByTag(dev->sckTag));
byte <<= 1; byte <<= 1;
if (GPIO_ReadInputDataBit(dev->miso_gpio, dev->miso_pin) == 1) { if (IORead(IOGetByTag(dev->misoTag)) == 1) {
byte |= 1; byte |= 1;
} }
GPIO_ResetBits(dev->sck_gpio, dev->sck_pin); IOLo(IOGetByTag(dev->sckTag));
} }
return byte; return byte;
} }

21
src/main/drivers/bus_spi_soft.h
View file

@ -17,17 +17,18 @@
#pragma once #pragma once
#include "io_types.h"
typedef enum softSPIDevice {
SOFT_SPIDEV_1 = 0,
SOFT_SPIDEV_MAX = SOFT_SPIDEV_1,
} softSPIDevice_e;
typedef struct softSPIDevice_s { typedef struct softSPIDevice_s {
GPIO_TypeDef* sck_gpio; ioTag_t sckTag;
uint16_t sck_pin; ioTag_t mosiTag;
GPIO_TypeDef* mosi_gpio; ioTag_t misoTag;
uint16_t mosi_pin; ioTag_t nssTag;
GPIO_TypeDef* miso_gpio;
uint16_t miso_pin;
#ifdef SOFTSPI_NSS_PIN
GPIO_TypeDef* nss_gpio;
uint16_t nss_pin;
#endif
} softSPIDevice_t; } softSPIDevice_t;

50
src/main/drivers/flash_m25p16.c
View file

@ -15,7 +15,6 @@
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>. * along with Cleanflight. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include <stdlib.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
@ -23,9 +22,10 @@
#ifdef USE_FLASH_M25P16 #ifdef USE_FLASH_M25P16
#include "drivers/flash_m25p16.h" #include "flash_m25p16.h"
#include "drivers/bus_spi.h" #include "io.h"
#include "drivers/system.h" #include "bus_spi.h"
#include "system.h"
#define M25P16_INSTRUCTION_RDID 0x9F #define M25P16_INSTRUCTION_RDID 0x9F
#define M25P16_INSTRUCTION_READ_BYTES 0x03 #define M25P16_INSTRUCTION_READ_BYTES 0x03
@ -44,11 +44,12 @@
#define JEDEC_ID_MICRON_M25P16 0x202015 #define JEDEC_ID_MICRON_M25P16 0x202015
#define JEDEC_ID_MICRON_N25Q064 0x20BA17 #define JEDEC_ID_MICRON_N25Q064 0x20BA17
#define JEDEC_ID_WINBOND_W25Q64 0xEF4017 #define JEDEC_ID_WINBOND_W25Q64 0xEF4017
#define JEDEC_ID_MACRONIX_MX25L6406E 0xC22017
#define JEDEC_ID_MICRON_N25Q128 0x20ba18 #define JEDEC_ID_MICRON_N25Q128 0x20ba18
#define JEDEC_ID_WINBOND_W25Q128 0xEF4018 #define JEDEC_ID_WINBOND_W25Q128 0xEF4018
#define DISABLE_M25P16 GPIO_SetBits(M25P16_CS_GPIO, M25P16_CS_PIN) #define DISABLE_M25P16 IOHi(m25p16CsPin)
#define ENABLE_M25P16 GPIO_ResetBits(M25P16_CS_GPIO, M25P16_CS_PIN) #define ENABLE_M25P16 IOLo(m25p16CsPin)
// The timeout we expect between being able to issue page program instructions // The timeout we expect between being able to issue page program instructions
#define DEFAULT_TIMEOUT_MILLIS 6 #define DEFAULT_TIMEOUT_MILLIS 6
@ -59,6 +60,8 @@
static flashGeometry_t geometry = {.pageSize = M25P16_PAGESIZE}; static flashGeometry_t geometry = {.pageSize = M25P16_PAGESIZE};
static IO_t m25p16CsPin = IO_NONE;
/* /*
* Whether we've performed an action that could have made the device busy for writes. * Whether we've performed an action that could have made the device busy for writes.
* *
@ -92,7 +95,7 @@ static void m25p16_writeEnable()
static uint8_t m25p16_readStatus() static uint8_t m25p16_readStatus()
{ {
uint8_t command[2] = {M25P16_INSTRUCTION_READ_STATUS_REG, 0}; uint8_t command[2] = { M25P16_INSTRUCTION_READ_STATUS_REG, 0 };
uint8_t in[2]; uint8_t in[2];
ENABLE_M25P16; ENABLE_M25P16;
@ -131,7 +134,7 @@ bool m25p16_waitForReady(uint32_t timeoutMillis)
*/ */
static bool m25p16_readIdentification() static bool m25p16_readIdentification()
{ {
uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0}; uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0 };
uint8_t in[4]; uint8_t in[4];
uint32_t chipID; uint32_t chipID;
@ -161,6 +164,7 @@ static bool m25p16_readIdentification()
break; break;
case JEDEC_ID_MICRON_N25Q064: case JEDEC_ID_MICRON_N25Q064:
case JEDEC_ID_WINBOND_W25Q64: case JEDEC_ID_WINBOND_W25Q64:
case JEDEC_ID_MACRONIX_MX25L6406E:
geometry.sectors = 128; geometry.sectors = 128;
geometry.pagesPerSector = 256; geometry.pagesPerSector = 256;
break; break;
@ -193,10 +197,36 @@ static bool m25p16_readIdentification()
* Attempts to detect a connected m25p16. If found, true is returned and device capacity can be fetched with * Attempts to detect a connected m25p16. If found, true is returned and device capacity can be fetched with
* m25p16_getGeometry(). * m25p16_getGeometry().
*/ */
bool m25p16_init() bool m25p16_init(ioTag_t csTag)
{ {
/*
if we have already detected a flash device we can simply exit
TODO: change the init param in favour of flash CFG when ParamGroups work is done
then cs pin can be specified in hardware_revision.c or config.c (dependent on revision).
*/
if (geometry.sectors) {
return true;
}
if (csTag) {
m25p16CsPin = IOGetByTag(csTag);
} else {
#ifdef M25P16_CS_PIN
m25p16CsPin = IOGetByTag(IO_TAG(M25P16_CS_PIN));
#else
return false;
#endif
}
IOInit(m25p16CsPin, OWNER_FLASH, RESOURCE_SPI_CS, 0);
IOConfigGPIO(m25p16CsPin, SPI_IO_CS_CFG);
DISABLE_M25P16;
#ifndef M25P16_SPI_SHARED
//Maximum speed for standard READ command is 20mHz, other commands tolerate 25mHz //Maximum speed for standard READ command is 20mHz, other commands tolerate 25mHz
spiSetDivisor(M25P16_SPI_INSTANCE, SPI_18MHZ_CLOCK_DIVIDER); spiSetDivisor(M25P16_SPI_INSTANCE, SPI_CLOCK_FAST);
#endif
return m25p16_readIdentification(); return m25p16_readIdentification();
} }

3
src/main/drivers/flash_m25p16.h
View file

@ -19,10 +19,11 @@
#include <stdint.h> #include <stdint.h>
#include "flash.h" #include "flash.h"
#include "io_types.h"
#define M25P16_PAGESIZE 256 #define M25P16_PAGESIZE 256
bool m25p16_init(); bool m25p16_init(ioTag_t csTag);
void m25p16_eraseSector(uint32_t address); void m25p16_eraseSector(uint32_t address);
void m25p16_eraseCompletely(); void m25p16_eraseCompletely();

5
src/main/drivers/io.c
View file

@ -56,13 +56,14 @@ const struct ioPortDef_s ioPortDefs[] = {
const char * const ownerNames[OWNER_TOTAL_COUNT] = { const char * const ownerNames[OWNER_TOTAL_COUNT] = {
"FREE", "PWM", "PPM", "MOTOR", "SERVO", "SOFTSERIAL", "ADC", "SERIAL", "DEBUG", "TIMER", "FREE", "PWM", "PPM", "MOTOR", "SERVO", "SOFTSERIAL", "ADC", "SERIAL", "DEBUG", "TIMER",
"SONAR", "SYSTEM", "SPI", "I2C", "SDCARD", "FLASH", "USB", "BEEPER", "OSD", "SONAR", "SYSTEM", "SPI", "I2C", "SDCARD", "FLASH", "USB", "BEEPER", "OSD",
"BARO", "MPU", "INVERTER", "LED STRIP", "LED", "RECEIVER", "TRANSMITTER" "BARO", "MPU", "INVERTER", "LED STRIP", "LED", "RECEIVER", "TRANSMITTER",
"SOFTSPI", "NRF24"
}; };
const char * const resourceNames[RESOURCE_TOTAL_COUNT] = { const char * const resourceNames[RESOURCE_TOTAL_COUNT] = {
"", // NONE "", // NONE
"IN", "OUT", "IN / OUT", "TIMER","UART TX","UART RX","UART TX/RX","EXTI","SCL", "IN", "OUT", "IN / OUT", "TIMER","UART TX","UART RX","UART TX/RX","EXTI","SCL",
"SDA", "SCK","MOSI","MISO","CS","BATTERY","RSSI","EXT","CURRENT" "SDA", "SCK","MOSI","MISO","CS","BATTERY","RSSI","EXT","CURRENT", "CE"
}; };

3
src/main/drivers/resource.h
View file

@ -30,6 +30,8 @@ typedef enum {
OWNER_LED, OWNER_LED,
OWNER_RX, OWNER_RX,
OWNER_TX, OWNER_TX,
OWNER_SOFTSPI,
OWNER_NRF24,
OWNER_TOTAL_COUNT OWNER_TOTAL_COUNT
} resourceOwner_t; } resourceOwner_t;
@ -46,6 +48,7 @@ typedef enum {
RESOURCE_I2C_SCL, RESOURCE_I2C_SDA, RESOURCE_I2C_SCL, RESOURCE_I2C_SDA,
RESOURCE_SPI_SCK, RESOURCE_SPI_MOSI, RESOURCE_SPI_MISO, RESOURCE_SPI_CS, RESOURCE_SPI_SCK, RESOURCE_SPI_MOSI, RESOURCE_SPI_MISO, RESOURCE_SPI_CS,
RESOURCE_ADC_BATTERY, RESOURCE_ADC_RSSI, RESOURCE_ADC_EXTERNAL1, RESOURCE_ADC_CURRENT, RESOURCE_ADC_BATTERY, RESOURCE_ADC_RSSI, RESOURCE_ADC_EXTERNAL1, RESOURCE_ADC_CURRENT,
RESOURCE_NRF24_CE,
RESOURCE_TOTAL_COUNT RESOURCE_TOTAL_COUNT
} resourceType_t; } resourceType_t;

67
src/main/drivers/rx_nrf24l01.c
View file

@ -26,8 +26,12 @@
#ifdef USE_RX_NRF24 #ifdef USE_RX_NRF24
#include "build_config.h"
#include "system.h" #include "system.h"
#include "gpio.h" #include "gpio.h"
#include "io.h"
#include "io_impl.h"
#include "rcc.h"
#include "rx_nrf24l01.h" #include "rx_nrf24l01.h"
#ifdef UNIT_TEST #ifdef UNIT_TEST
@ -41,25 +45,20 @@ void NRF24L01_SpiInit(void) {}
#include "bus_spi.h" #include "bus_spi.h"
#include "bus_spi_soft.h" #include "bus_spi_soft.h"
#define DISABLE_NRF24() {GPIO_SetBits(NRF24_CSN_GPIO, NRF24_CSN_PIN);} #define DISABLE_NRF24() {IOHi(IOGetByTag(IO_TAG(NRF24_CSN_PIN)));}
#define ENABLE_NRF24() {GPIO_ResetBits(NRF24_CSN_GPIO, NRF24_CSN_PIN);} #define ENABLE_NRF24() {IOLo(IOGetByTag(IO_TAG(NRF24_CSN_PIN)));}
#define NRF24_CE_HI() {GPIO_SetBits(NRF24_CE_GPIO, NRF24_CE_PIN);} #define NRF24_CE_HI() {IOHi(IOGetByTag(IO_TAG(NRF24_CE_PIN)));}
#define NRF24_CE_LO() {GPIO_ResetBits(NRF24_CE_GPIO, NRF24_CE_PIN);} #define NRF24_CE_LO() {IOLo(IOGetByTag(IO_TAG(NRF24_CE_PIN)));}
#ifdef USE_NRF24_SOFTSPI #ifdef USE_NRF24_SOFTSPI
static const softSPIDevice_t softSPIDevice = { static const softSPIDevice_t softSPIDevice = {
.sck_gpio = NRF24_SCK_GPIO, .sckTag = IO_TAG(NRF24_SCK_PIN),
.mosi_gpio = NRF24_MOSI_GPIO, .mosiTag = IO_TAG(NRF24_MOSI_PIN),
.miso_gpio = NRF24_MISO_GPIO, .misoTag = IO_TAG(NRF24_MISO_PIN),
.sck_pin = NRF24_SCK_PIN, // Note: Nordic Semiconductor uses 'CSN', STM uses 'NSS'
.mosi_pin = NRF24_MOSI_PIN, .nssTag = IO_TAG(NRF24_CSN_PIN),
.miso_pin = NRF24_MISO_PIN,
#ifdef SOFTSPI_NSS_PIN
.nss_pin = NRF24_CSN_PIN,
.nss_gpio = NRF24_CSN_GPIO
#endif
}; };
#endif #endif // USE_NRF24_SOFTSPI
#ifdef USE_NRF24_SOFTSPI #ifdef USE_NRF24_SOFTSPI
static bool useSoftSPI = false; static bool useSoftSPI = false;
@ -71,39 +70,35 @@ void NRF24L01_SpiInit(nfr24l01_spi_type_e spiType)
if (hardwareInitialised) { if (hardwareInitialised) {
return; return;
} }
if (spiType == NFR24L01_SOFTSPI) {
#ifdef USE_NRF24_SOFTSPI #ifdef USE_NRF24_SOFTSPI
if (spiType == NFR24L01_SOFTSPI) {
useSoftSPI = true; useSoftSPI = true;
softSpiInit(&softSPIDevice); softSpiInit(&softSPIDevice);
#endif
} }
// Note: Nordic Semiconductor uses 'CSN', STM uses 'NSS' const SPIDevice nrf24SPIDevice = SOFT_SPIDEV_1;
GPIO_InitTypeDef GPIO_InitStructure; #else
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; UNUSED(spiType);
#if defined(STM32F10X) const SPIDevice nrf24SPIDevice = spiDeviceByInstance(NRF24_SPI_INSTANCE);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; IOInit(IOGetByTag(IO_TAG(NRF24_CSN_PIN)), OWNER_SPI, RESOURCE_SPI_CS, nrf24SPIDevice + 1);
#endif #endif // USE_NRF24_SOFTSPI
#ifdef STM32F303xC
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
#endif
#ifndef SOFTSPI_NSS_PIN
// CSN as output
RCC_AHBPeriphClockCmd(NRF24_CSN_GPIO_CLK_PERIPHERAL, ENABLE); RCC_AHBPeriphClockCmd(NRF24_CSN_GPIO_CLK_PERIPHERAL, ENABLE);
GPIO_InitStructure.GPIO_Pin = NRF24_CSN_PIN;
GPIO_Init(NRF24_CSN_GPIO, &GPIO_InitStructure);
#endif
// CE as OUTPUT // CE as OUTPUT
RCC_AHBPeriphClockCmd(NRF24_CE_GPIO_CLK_PERIPHERAL, ENABLE); RCC_AHBPeriphClockCmd(NRF24_CE_GPIO_CLK_PERIPHERAL, ENABLE);
GPIO_InitStructure.GPIO_Pin = NRF24_CE_PIN; IOInit(IOGetByTag(IO_TAG(NRF24_CE_PIN)), OWNER_NRF24, RESOURCE_NRF24_CE, nrf24SPIDevice + 1);
GPIO_Init(NRF24_CE_GPIO, &GPIO_InitStructure); #if defined(STM32F10X)
IOConfigGPIO(IOGetByTag(IO_TAG(NRF24_CE_PIN)), SPI_IO_CS_CFG);
#elif defined(STM32F3) || defined(STM32F4)
IOConfigGPIOAF(IOGetByTag(IO_TAG(NRF24_CE_PIN)), SPI_IO_CS_CFG, 0);
#endif
DISABLE_NRF24(); DISABLE_NRF24();
NRF24_CE_LO(); NRF24_CE_LO();
#ifdef NRF24_SPI_INSTANCE #ifdef NRF24_SPI_INSTANCE
spiSetDivisor(NRF24_SPI_INSTANCE, SPI_9MHZ_CLOCK_DIVIDER); spiSetDivisor(NRF24_SPI_INSTANCE, SPI_CLOCK_STANDARD);
#endif #endif
hardwareInitialised = true; hardwareInitialised = true;
} }

97
src/main/drivers/sdcard.c
View file

@ -15,37 +15,35 @@
* along with Cleanflight. If not, see <http://www.gnu.org/licenses/>. * along with Cleanflight. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "sdcard.h"
#include <stdlib.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#include <platform.h> #include "platform.h"
#include "nvic.h"
#include "gpio.h"
#include "drivers/bus_spi.h"
#include "drivers/system.h"
#include "sdcard_standard.h"
#ifdef USE_SDCARD #ifdef USE_SDCARD
#include "nvic.h"
#include "io.h"
#include "bus_spi.h"
#include "system.h"
#include "sdcard.h"
#include "sdcard_standard.h"
#ifdef AFATFS_USE_INTROSPECTIVE_LOGGING #ifdef AFATFS_USE_INTROSPECTIVE_LOGGING
#define SDCARD_PROFILING #define SDCARD_PROFILING
#endif #endif
#define SET_CS_HIGH GPIO_SetBits(SDCARD_SPI_CS_GPIO, SDCARD_SPI_CS_PIN) #define SET_CS_HIGH IOHi(sdCardCsPin)
#define SET_CS_LOW GPIO_ResetBits(SDCARD_SPI_CS_GPIO, SDCARD_SPI_CS_PIN) #define SET_CS_LOW IOLo(sdCardCsPin)
#define SDCARD_INIT_NUM_DUMMY_BYTES 10 #define SDCARD_INIT_NUM_DUMMY_BYTES 10
#define SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY 8 #define SDCARD_MAXIMUM_BYTE_DELAY_FOR_CMD_REPLY 8
// Chosen so that CMD8 will have the same CRC as CMD0: // Chosen so that CMD8 will have the same CRC as CMD0:
#define SDCARD_IF_COND_CHECK_PATTERN 0xAB #define SDCARD_IF_COND_CHECK_PATTERN 0xAB
#define SDCARD_TIMEOUT_INIT_MILLIS 2000 #define SDCARD_TIMEOUT_INIT_MILLIS 200
#define SDCARD_MAX_CONSECUTIVE_FAILURES 8 #define SDCARD_MAX_CONSECUTIVE_FAILURES 8
/* Break up 512-byte SD card sectors into chunks of this size when writing without DMA to reduce the peak overhead /* Break up 512-byte SD card sectors into chunks of this size when writing without DMA to reduce the peak overhead
@ -117,25 +115,27 @@ static sdcard_t sdcard;
STATIC_ASSERT(sizeof(sdcardCSD_t) == 16, sdcard_csd_bitfields_didnt_pack_properly); STATIC_ASSERT(sizeof(sdcardCSD_t) == 16, sdcard_csd_bitfields_didnt_pack_properly);
#ifdef SDCARD_DETECT_PIN
static IO_t sdCardDetectPin = IO_NONE;
#endif
static IO_t sdCardCsPin = IO_NONE;
void sdcardInsertionDetectDeinit(void) void sdcardInsertionDetectDeinit(void)
{ {
#ifdef SDCARD_DETECT_PIN #ifdef SDCARD_DETECT_PIN
GPIO_InitTypeDef GPIO_InitStructure; sdCardDetectPin = IOGetByTag(IO_TAG(SDCARD_DETECT_PIN));
IOInit(sdCardDetectPin, OWNER_FREE, RESOURCE_NONE, 0);
GPIO_InitStructure.GPIO_Pin = SDCARD_DETECT_PIN; IOConfigGPIO(sdCardDetectPin, IOCFG_IN_FLOATING);
GPIO_Init(SDCARD_DETECT_GPIO_PORT, &GPIO_InitStructure);
#endif #endif
} }
void sdcardInsertionDetectInit(void) void sdcardInsertionDetectInit(void)
{ {
#ifdef SDCARD_DETECT_PIN #ifdef SDCARD_DETECT_PIN
GPIO_InitTypeDef GPIO_InitStructure; sdCardDetectPin = IOGetByTag(IO_TAG(SDCARD_DETECT_PIN));
IOInit(sdCardDetectPin, OWNER_SDCARD, RESOURCE_INPUT, 0);
GPIO_InitStructure.GPIO_Pin = SDCARD_DETECT_PIN; IOConfigGPIO(sdCardDetectPin, IOCFG_IPU);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(SDCARD_DETECT_GPIO_PORT, &GPIO_InitStructure);
#endif #endif
} }
@ -148,7 +148,7 @@ bool sdcard_isInserted(void)
#ifdef SDCARD_DETECT_PIN #ifdef SDCARD_DETECT_PIN
result = (GPIO_ReadInputData(SDCARD_DETECT_GPIO_PORT) & SDCARD_DETECT_PIN) != 0; result = IORead(sdCardDetectPin) != 0;
#ifdef SDCARD_DETECT_INVERTED #ifdef SDCARD_DETECT_INVERTED
result = !result; result = !result;
@ -192,6 +192,11 @@ static void sdcard_deselect(void)
*/ */
static void sdcard_reset(void) static void sdcard_reset(void)
{ {
if (!sdcard_isInserted()) {
sdcard.state = SDCARD_STATE_NOT_PRESENT;
return;
}
if (sdcard.state >= SDCARD_STATE_READY) { if (sdcard.state >= SDCARD_STATE_READY) {
spiSetDivisor(SDCARD_SPI_INSTANCE, SDCARD_SPI_INITIALIZATION_CLOCK_DIVIDER); spiSetDivisor(SDCARD_SPI_INSTANCE, SDCARD_SPI_INITIALIZATION_CLOCK_DIVIDER);
} }
@ -407,22 +412,32 @@ static void sdcard_sendDataBlockBegin(uint8_t *buffer, bool multiBlockWrite)
spiTransferByte(SDCARD_SPI_INSTANCE, multiBlockWrite ? SDCARD_MULTIPLE_BLOCK_WRITE_START_TOKEN : SDCARD_SINGLE_BLOCK_WRITE_START_TOKEN); spiTransferByte(SDCARD_SPI_INSTANCE, multiBlockWrite ? SDCARD_MULTIPLE_BLOCK_WRITE_START_TOKEN : SDCARD_SINGLE_BLOCK_WRITE_START_TOKEN);
if (useDMAForTx) { if (useDMAForTx) {
#ifdef SDCARD_DMA_CHANNEL_TX
// Queue the transmission of the sector payload // Queue the transmission of the sector payload
#ifdef SDCARD_DMA_CLK
RCC_AHB1PeriphClockCmd(SDCARD_DMA_CLK, ENABLE);
#endif
DMA_InitTypeDef DMA_InitStructure; DMA_InitTypeDef DMA_InitStructure;
DMA_StructInit(&DMA_InitStructure); DMA_StructInit(&DMA_InitStructure);
#ifdef SDCARD_DMA_CHANNEL
DMA_InitStructure.DMA_Channel = SDCARD_DMA_CHANNEL;
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t) buffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
#else
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) buffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
#endif
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) &SDCARD_SPI_INSTANCE->DR; DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t) &SDCARD_SPI_INSTANCE->DR;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low; DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) buffer;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_BufferSize = SDCARD_BLOCK_SIZE; DMA_InitStructure.DMA_BufferSize = SDCARD_BLOCK_SIZE;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_DeInit(SDCARD_DMA_CHANNEL_TX); DMA_DeInit(SDCARD_DMA_CHANNEL_TX);
@ -431,7 +446,9 @@ static void sdcard_sendDataBlockBegin(uint8_t *buffer, bool multiBlockWrite)
DMA_Cmd(SDCARD_DMA_CHANNEL_TX, ENABLE); DMA_Cmd(SDCARD_DMA_CHANNEL_TX, ENABLE);
SPI_I2S_DMACmd(SDCARD_SPI_INSTANCE, SPI_I2S_DMAReq_Tx, ENABLE); SPI_I2S_DMACmd(SDCARD_SPI_INSTANCE, SPI_I2S_DMAReq_Tx, ENABLE);
} else { #endif
}
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, NULL, buffer, SDCARD_NON_DMA_CHUNK_SIZE);
} }
@ -532,6 +549,12 @@ void sdcard_init(bool useDMA)
(void) useDMA; (void) useDMA;
#endif #endif
#ifdef SDCARD_SPI_CS_PIN
sdCardCsPin = IOGetByTag(IO_TAG(SDCARD_SPI_CS_PIN));
IOInit(sdCardCsPin, OWNER_SDCARD, RESOURCE_SPI_CS, 0);
IOConfigGPIO(sdCardCsPin, SPI_IO_CS_CFG);
#endif // SDCARD_SPI_CS_PIN
// Max frequency is initially 400kHz // Max frequency is initially 400kHz
spiSetDivisor(SDCARD_SPI_INSTANCE, SDCARD_SPI_INITIALIZATION_CLOCK_DIVIDER); spiSetDivisor(SDCARD_SPI_INSTANCE, SDCARD_SPI_INITIALIZATION_CLOCK_DIVIDER);
@ -544,7 +567,13 @@ void sdcard_init(bool useDMA)
spiTransfer(SDCARD_SPI_INSTANCE, NULL, NULL, SDCARD_INIT_NUM_DUMMY_BYTES); spiTransfer(SDCARD_SPI_INSTANCE, NULL, NULL, SDCARD_INIT_NUM_DUMMY_BYTES);
// Wait for that transmission to finish before we enable the SDCard, so it receives the required number of cycles: // Wait for that transmission to finish before we enable the SDCard, so it receives the required number of cycles:
int time = 100000;
while (spiIsBusBusy(SDCARD_SPI_INSTANCE)) { while (spiIsBusBusy(SDCARD_SPI_INSTANCE)) {
if (time-- == 0) {
sdcard.state = SDCARD_STATE_NOT_PRESENT;
sdcard.failureCount++;
return;
}
} }
sdcard.operationStartTime = millis(); sdcard.operationStartTime = millis();
@ -699,8 +728,14 @@ bool sdcard_poll(void)
// Have we finished sending the write yet? // Have we finished sending the write yet?
sendComplete = false; sendComplete = false;
#ifdef SDCARD_DMA_CHANNEL_TX
#ifdef SDCARD_DMA_CHANNEL
if (useDMAForTx && DMA_GetFlagStatus(SDCARD_DMA_CHANNEL_TX, SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG) == SET) {
DMA_ClearFlag(SDCARD_DMA_CHANNEL_TX, SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG);
#else
if (useDMAForTx && DMA_GetFlagStatus(SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG) == SET) { if (useDMAForTx && DMA_GetFlagStatus(SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG) == SET) {
DMA_ClearFlag(SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG); DMA_ClearFlag(SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG);
#endif
DMA_Cmd(SDCARD_DMA_CHANNEL_TX, DISABLE); DMA_Cmd(SDCARD_DMA_CHANNEL_TX, DISABLE);
@ -717,7 +752,7 @@ bool sdcard_poll(void)
sendComplete = true; sendComplete = true;
} }
#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, NULL, sdcard.pendingOperation.buffer + SDCARD_NON_DMA_CHUNK_SIZE * sdcard.pendingOperation.chunkIndex, SDCARD_NON_DMA_CHUNK_SIZE);

29
src/main/io/serial_cli.c
View file

@ -44,6 +44,8 @@
#include "drivers/serial.h" #include "drivers/serial.h"
#include "drivers/bus_i2c.h" #include "drivers/bus_i2c.h"
#include "drivers/gpio.h" #include "drivers/gpio.h"
#include "drivers/io.h"
#include "drivers/io_impl.h"
#include "drivers/timer.h" #include "drivers/timer.h"
#include "drivers/pwm_rx.h" #include "drivers/pwm_rx.h"
#include "drivers/sdcard.h" #include "drivers/sdcard.h"
@ -135,6 +137,9 @@ static void cliVersion(char *cmdline);
static void cliRxRange(char *cmdline); static void cliRxRange(char *cmdline);
static void cliPFlags(char *cmdline); static void cliPFlags(char *cmdline);
#ifndef SKIP_TASK_STATISTICS
static void cliResource(char *cmdline);
#endif
#ifdef GPS #ifdef GPS
static void cliGpsPassthrough(char *cmdline); static void cliGpsPassthrough(char *cmdline);
#endif #endif
@ -296,6 +301,9 @@ const clicmd_t cmdTable[] = {
CLI_COMMAND_DEF("profile", "change profile", CLI_COMMAND_DEF("profile", "change profile",
"[<index>]", cliProfile), "[<index>]", cliProfile),
CLI_COMMAND_DEF("rateprofile", "change rate profile", "[<index>]", cliRateProfile), CLI_COMMAND_DEF("rateprofile", "change rate profile", "[<index>]", cliRateProfile),
#ifndef SKIP_TASK_STATISTICS
CLI_COMMAND_DEF("resource", "view currently used resources", NULL, cliResource),
#endif
CLI_COMMAND_DEF("rxrange", "configure rx channel ranges", NULL, cliRxRange), CLI_COMMAND_DEF("rxrange", "configure rx channel ranges", NULL, cliRxRange),
CLI_COMMAND_DEF("rxfail", "show/set rx failsafe settings", NULL, cliRxFail), CLI_COMMAND_DEF("rxfail", "show/set rx failsafe settings", NULL, cliRxFail),
CLI_COMMAND_DEF("save", "save and reboot", NULL, cliSave), CLI_COMMAND_DEF("save", "save and reboot", NULL, cliSave),
@ -2901,6 +2909,27 @@ void cliProcess(void)
} }
} }
#ifndef SKIP_TASK_STATISTICS
static void cliResource(char *cmdline)
{
UNUSED(cmdline);
cliPrintf("IO:\r\n----------------------\r\n");
for (unsigned i = 0; i < DEFIO_IO_USED_COUNT; i++) {
const char* owner;
owner = ownerNames[ioRecs[i].owner];
const char* resource;
resource = resourceNames[ioRecs[i].resource];
if (ioRecs[i].index > 0) {
cliPrintf("%c%02d: %s%d %s\r\n", IO_GPIOPortIdx(ioRecs + i) + 'A', IO_GPIOPinIdx(ioRecs + i), owner, ioRecs[i].index, resource);
} else {
cliPrintf("%c%02d: %s %s\r\n", IO_GPIOPortIdx(ioRecs + i) + 'A', IO_GPIOPinIdx(ioRecs + i), owner, resource);
}
}
}
#endif
void cliInit(serialConfig_t *serialConfig) void cliInit(serialConfig_t *serialConfig)
{ {
UNUSED(serialConfig); UNUSED(serialConfig);

21
src/main/main.c
View file

@ -309,8 +309,21 @@ void init(void)
#ifdef USE_SPI #ifdef USE_SPI
spiInit(SPI1); #ifdef USE_SPI_DEVICE_1
spiInit(SPI2); spiInit(SPIDEV_1);
#endif
#ifdef USE_SPI_DEVICE_2
spiInit(SPIDEV_2);
#endif
#ifdef USE_SPI_DEVICE_3
#ifdef ALIENFLIGHTF3
if (hardwareRevision == AFF3_REV_2) {
spiInit(SPIDEV_3);
}
#else
spiInit(SPIDEV_3);
#endif
#endif
#endif #endif
#ifdef USE_HARDWARE_REVISION_DETECTION #ifdef USE_HARDWARE_REVISION_DETECTION
@ -475,10 +488,10 @@ void init(void)
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
#ifdef NAZE #ifdef NAZE
if (hardwareRevision == NAZE32_REV5) { if (hardwareRevision == NAZE32_REV5) {
m25p16_init(); m25p16_init(IOTAG_NONE);
} }
#elif defined(USE_FLASH_M25P16) #elif defined(USE_FLASH_M25P16)
m25p16_init(); m25p16_init(IOTAG_NONE);
#endif #endif
flashfsInit(); flashfsInit();

6
src/main/target/ALIENFLIGHTF3/target.h
View file

@ -86,13 +86,11 @@
#define USE_SPI #define USE_SPI
#define USE_SPI_DEVICE_3 #define USE_SPI_DEVICE_3
#define M25P16_CS_GPIO GPIOA #define M25P16_CS_PIN PA15
#define M25P16_CS_PIN GPIO_Pin_15
#define M25P16_SPI_INSTANCE SPI3 #define M25P16_SPI_INSTANCE SPI3
#define MPU6500_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOA #define MPU6500_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOA
#define MPU6500_CS_GPIO GPIOA #define MPU6500_CS_PIN PA15
#define MPU6500_CS_PIN GPIO_Pin_15
#define MPU6500_SPI_INSTANCE SPI3 #define MPU6500_SPI_INSTANCE SPI3
#define USE_ADC #define USE_ADC

33
src/main/target/CC3D/target.h
View file

@ -37,12 +37,10 @@
#define USE_I2C #define USE_I2C
#define I2C_DEVICE (I2CDEV_2) // Flex port - SCL/PB10, SDA/PB11 #define I2C_DEVICE (I2CDEV_2) // Flex port - SCL/PB10, SDA/PB11
#define MPU6000_CS_GPIO GPIOA #define MPU6000_CS_PIN PA4
#define MPU6000_CS_PIN GPIO_Pin_4
#define MPU6000_SPI_INSTANCE SPI1 #define MPU6000_SPI_INSTANCE SPI1
#define M25P16_CS_GPIO GPIOB #define M25P16_CS_PIN PB12
#define M25P16_CS_PIN GPIO_Pin_12
#define M25P16_SPI_INSTANCE SPI2 #define M25P16_SPI_INSTANCE SPI2
#define USE_FLASHFS #define USE_FLASHFS
@ -58,7 +56,7 @@
// External I2C BARO // External I2C BARO
#define BARO #define BARO
#define USE_BARO_MS5611 //#define USE_BARO_MS5611
#define USE_BARO_BMP085 #define USE_BARO_BMP085
#define USE_BARO_BMP280 #define USE_BARO_BMP280
@ -106,18 +104,14 @@
// RC8 PA1/TIM2 CE / RX_PPM // RC8 PA1/TIM2 CE / RX_PPM
// Nordic Semiconductor uses 'CSN', STM uses 'NSS' // Nordic Semiconductor uses 'CSN', STM uses 'NSS'
#define NRF24_CE_GPIO GPIOA
#define NRF24_CE_PIN GPIO_Pin_1
#define NRF24_CE_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define NRF24_CSN_GPIO GPIOA
#define NRF24_CSN_PIN GPIO_Pin_0
#define NRF24_CSN_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA #define NRF24_CSN_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define NRF24_SCK_GPIO GPIOB #define NRF24_CSN_PIN PA0
#define NRF24_SCK_PIN GPIO_Pin_5 #define NRF24_CE_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define NRF24_MOSI_GPIO GPIOB #define NRF24_CE_PIN PA1
#define NRF24_MOSI_PIN GPIO_Pin_1 #define NRF24_CSN_PIN PA0
#define NRF24_MISO_GPIO GPIOB #define NRF24_SCK_PIN PB5
#define NRF24_MISO_PIN GPIO_Pin_0 #define NRF24_MOSI_PIN PB1
#define NRF24_MISO_PIN PB0
#define SERIAL_PORT_COUNT 3 #define SERIAL_PORT_COUNT 3
@ -162,7 +156,7 @@
//#define USE_SERIAL_4WAY_BLHELI_INTERFACE //#define USE_SERIAL_4WAY_BLHELI_INTERFACE
//#define SONAR //#define SONAR
#define USE_SONAR_SRF10 //#define USE_SONAR_SRF10
#define SONAR_ECHO_PIN PB0 #define SONAR_ECHO_PIN PB0
#define SONAR_TRIGGER_PIN PB5 #define SONAR_TRIGGER_PIN PB5
@ -195,12 +189,15 @@
#undef SERIAL_RX #undef SERIAL_RX
#undef SPEKTRUM_BIND #undef SPEKTRUM_BIND
#else
#define TARGET_MOTOR_COUNT 6
#define DISABLE_UNCOMMON_MIXERS
#endif //OPBL #endif //OPBL
#define SKIP_RX_MSP
#ifdef USE_RX_NRF24 #ifdef USE_RX_NRF24
#define SKIP_RX_PWM_PPM #define SKIP_RX_PWM_PPM
#define SKIP_RX_MSP
#undef SERIAL_RX #undef SERIAL_RX
#undef SPEKTRUM_BIND #undef SPEKTRUM_BIND
#undef TELEMETRY #undef TELEMETRY

3
src/main/target/CHEBUZZF3/target.h
View file

@ -35,8 +35,7 @@
#define L3GD20_SPI SPI1 #define L3GD20_SPI SPI1
#define L3GD20_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOE #define L3GD20_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOE
#define L3GD20_CS_GPIO GPIOE #define L3GD20_CS_PIN PE3
#define L3GD20_CS_PIN GPIO_Pin_3
#define GYRO_L3GD20_ALIGN CW270_DEG #define GYRO_L3GD20_ALIGN CW270_DEG
#define GYRO_MPU6050_ALIGN CW0_DEG #define GYRO_MPU6050_ALIGN CW0_DEG

34
src/main/target/CJMCU/target.h
View file

@ -20,8 +20,6 @@
#define TARGET_BOARD_IDENTIFIER "CJM1" // CJMCU #define TARGET_BOARD_IDENTIFIER "CJM1" // CJMCU
#define USE_HARDWARE_REVISION_DETECTION #define USE_HARDWARE_REVISION_DETECTION
#define BRUSHED_MOTORS
#define LED0 PC14 #define LED0 PC14
#define LED1 PC13 #define LED1 PC13
#define LED2 PC15 #define LED2 PC15
@ -35,7 +33,7 @@
#define USE_ACC_MPU6050 #define USE_ACC_MPU6050
//#define MAG //#define MAG
#define USE_MAG_HMC5883 //#define USE_MAG_HMC5883
#define USE_UART1 #define USE_UART1
#define USE_UART2 #define USE_UART2
@ -54,22 +52,27 @@
#define USE_NRF24_SPI1 #define USE_NRF24_SPI1
// Nordic Semiconductor uses 'CSN', STM uses 'NSS' // Nordic Semiconductor uses 'CSN', STM uses 'NSS'
#define NRF24_CE_GPIO GPIOA
#define NRF24_CE_PIN GPIO_Pin_4
#define NRF24_CE_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA #define NRF24_CE_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define NRF24_CSN_GPIO GPIOA
#define NRF24_CSN_PIN GPIO_Pin_11
#define NRF24_CSN_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA #define NRF24_CSN_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define NRF24_IRQ_GPIO GPIOA
#define NRF24_IRQ_PIN GPIO_Pin_8
#define NRF24_IRQ_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA #define NRF24_IRQ_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define NRF24_CE_PIN PA4
#define NRF24_CSN_PIN PA11
#define NRF24_SCK_PIN PA5
#define NRF24_MISO_PIN PA6
#define NRF24_MOSI_PIN PA7
#define NRF24_IRQ_PIN PA8
// CJMCU has NSS on PA11, rather than the standard PA4
#define SPI1_NSS_PIN NRF24_CSN_PIN
#define SPI1_SCK_PIN NRF24_SCK_PIN
#define SPI1_MISO_PIN NRF24_MISO_PIN
#define SPI1_MOSI_PIN NRF24_MOSI_PIN
#define USE_RX_NRF24 #define USE_RX_NRF24
#define USE_RX_CX10 #define USE_RX_CX10
#define USE_RX_H8_3D #define USE_RX_H8_3D
#define USE_RX_REF #define USE_RX_REF
#define USE_RX_SYMA //#define USE_RX_SYMA
#define USE_RX_V202 //#define USE_RX_V202
//#define NRF24_DEFAULT_PROTOCOL NRF24RX_SYMA_X5C //#define NRF24_DEFAULT_PROTOCOL NRF24RX_SYMA_X5C
//#define NRF24_DEFAULT_PROTOCOL NRF24RX_REF //#define NRF24_DEFAULT_PROTOCOL NRF24RX_REF
#define NRF24_DEFAULT_PROTOCOL NRF24RX_H8_3D #define NRF24_DEFAULT_PROTOCOL NRF24RX_H8_3D
@ -78,25 +81,26 @@
#define DEFAULT_RX_FEATURE FEATURE_RX_NRF24 #define DEFAULT_RX_FEATURE FEATURE_RX_NRF24
#define SKIP_RX_PWM_PPM #define SKIP_RX_PWM_PPM
#undef SERIAL_RX
#undef SKIP_TASK_STATISTICS
#else #else
#define DEFAULT_RX_FEATURE FEATURE_RX_PPM #define DEFAULT_RX_FEATURE FEATURE_RX_PPM
#undef SKIP_RX_MSP #undef SKIP_RX_MSP
#define SPEKTRUM_BIND #define SPEKTRUM_BIND
// SART2, PA3 // UART2, PA3
#define BIND_PIN PA3 #define BIND_PIN PA3
#endif //USE_RX_NRF24 #endif //USE_RX_NRF24
#define BRUSHED_MOTORS
#define DEFAULT_FEATURES FEATURE_MOTOR_STOP #define DEFAULT_FEATURES FEATURE_MOTOR_STOP
#define SKIP_SERIAL_PASSTHROUGH
// Since the CJMCU PCB has holes for 4 motors in each corner we can save same flash space by disabling support for other mixers. // Since the CJMCU PCB has holes for 4 motors in each corner we can save same flash space by disabling support for other mixers.
#define USE_QUAD_MIXER_ONLY #define USE_QUAD_MIXER_ONLY
#undef USE_SERVOS #undef USE_SERVOS
#if (FLASH_SIZE <= 64) #if (FLASH_SIZE <= 64)
//#define SKIP_TASK_STATISTICS
//#define SKIP_CLI_COMMAND_HELP
#undef SERIAL_RX
#undef BLACKBOX #undef BLACKBOX
#endif #endif

16
src/main/target/COLIBRI_RACE/target.h
View file

@ -35,25 +35,19 @@
//#define DEBUG_MPU_DATA_READY_INTERRUPT //#define DEBUG_MPU_DATA_READY_INTERRUPT
#define MPU6500_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOA #define MPU6500_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOA
#define MPU6500_CS_GPIO GPIOA #define MPU6500_CS_PIN PA4
#define MPU6500_CS_PIN GPIO_Pin_4
#define MPU6500_SPI_INSTANCE SPI1 #define MPU6500_SPI_INSTANCE SPI1
#define MPU6000_CS_GPIO GPIOA #define MPU6000_CS_PIN PA4
#define MPU6000_CS_PIN GPIO_Pin_4
#define MPU6000_SPI_INSTANCE SPI1 #define MPU6000_SPI_INSTANCE SPI1
#define USE_SPI #define USE_SPI
#define USE_SPI_DEVICE_1 #define USE_SPI_DEVICE_1
#define SPI1_GPIO GPIOB
#define SPI1_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB #define SPI1_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB
#define SPI1_SCK_PIN GPIO_Pin_3 #define SPI1_SCK_PIN PB3
#define SPI1_SCK_PIN_SOURCE GPIO_PinSource3 #define SPI1_MISO_PIN PB4
#define SPI1_MISO_PIN GPIO_Pin_4 #define SPI1_MOSI_PIN PB5
#define SPI1_MISO_PIN_SOURCE GPIO_PinSource4
#define SPI1_MOSI_PIN GPIO_Pin_5
#define SPI1_MOSI_PIN_SOURCE GPIO_PinSource5
#define GYRO #define GYRO
#define USE_GYRO_MPU6500 #define USE_GYRO_MPU6500

15
src/main/target/CRAZEPONYMINI/target.h
View file

@ -34,8 +34,8 @@
#define BARO #define BARO
#define USE_BARO_MS5611 #define USE_BARO_MS5611
#define MAG //#define MAG
#define USE_MAG_HMC5883 //#define USE_MAG_HMC5883
#define USE_UART1 #define USE_UART1
#define SERIAL_PORT_COUNT 1 #define SERIAL_PORT_COUNT 1
@ -48,6 +48,8 @@
#define DEFAULT_RX_FEATURE FEATURE_RX_NRF24 #define DEFAULT_RX_FEATURE FEATURE_RX_NRF24
#define USE_RX_NRF24 #define USE_RX_NRF24
//#define USE_RX_CX10
//#define USE_RX_H8_3D
#define USE_RX_SYMA #define USE_RX_SYMA
#define USE_RX_V202 #define USE_RX_V202
#define NRF24_DEFAULT_PROTOCOL NRF24RX_V202_1M #define NRF24_DEFAULT_PROTOCOL NRF24RX_V202_1M
@ -59,14 +61,11 @@
#define USE_NRF24_SPI1 #define USE_NRF24_SPI1
// Nordic Semiconductor uses 'CSN', STM uses 'NSS' // Nordic Semiconductor uses 'CSN', STM uses 'NSS'
#define NRF24_CE_GPIO GPIOA #define NRF24_CE_PIN PA12
#define NRF24_CE_PIN GPIO_Pin_12
#define NRF24_CE_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA #define NRF24_CE_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define NRF24_CSN_GPIO GPIOA #define NRF24_CSN_PIN PA4
#define NRF24_CSN_PIN GPIO_Pin_4
#define NRF24_CSN_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA #define NRF24_CSN_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define NRF24_IRQ_GPIO GPIOA #define NRF24_IRQ_PIN PA15
#define NRF24_IRQ_PIN GPIO_Pin_15
#define NRF24_IRQ_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA #define NRF24_IRQ_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define SKIP_RX_MSP #define SKIP_RX_MSP

6
src/main/target/EUSTM32F103RC/target.h
View file

@ -25,13 +25,11 @@
#define INVERTER PB2 #define INVERTER PB2
#define INVERTER_USART USART2 #define INVERTER_USART USART2
#define MPU6000_CS_GPIO GPIOB #define MPU6000_CS_PIN PB12
#define MPU6000_CS_PIN GPIO_Pin_12
#define MPU6000_SPI_INSTANCE SPI2 #define MPU6000_SPI_INSTANCE SPI2
#define MPU6500_CS_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOB #define MPU6500_CS_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOB
#define MPU6500_CS_GPIO GPIOB #define MPU6500_CS_PIN PB12
#define MPU6500_CS_PIN GPIO_Pin_12
#define MPU6500_SPI_INSTANCE SPI2 #define MPU6500_SPI_INSTANCE SPI2
#define GYRO #define GYRO

35
src/main/target/FURYF3/target.h
View file

@ -31,15 +31,11 @@
#define USE_MPU_DATA_READY_SIGNAL #define USE_MPU_DATA_READY_SIGNAL
#define ENSURE_MPU_DATA_READY_IS_LOW #define ENSURE_MPU_DATA_READY_IS_LOW
#define MPU6000_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOA #define MPU6000_CS_PIN PA4
#define MPU6000_CS_GPIO GPIOA #define MPU6000_SPI_INSTANCE SPI1
#define MPU6000_CS_PIN GPIO_Pin_4
#define MPU6000_SPI_INSTANCE SPI1
#define MPU6500_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOA #define MPU6500_CS_PIN PA4
#define MPU6500_CS_GPIO GPIOA #define MPU6500_SPI_INSTANCE SPI1
#define MPU6500_CS_PIN GPIO_Pin_4
#define MPU6500_SPI_INSTANCE SPI1
#define GYRO #define GYRO
#define USE_GYRO_SPI_MPU6000 #define USE_GYRO_SPI_MPU6000
@ -68,16 +64,10 @@
#define USE_SPI_DEVICE_1 #define USE_SPI_DEVICE_1
#define USE_SPI_DEVICE_2 // PB12,13,14,15 on AF5 #define USE_SPI_DEVICE_2 // PB12,13,14,15 on AF5
#define SPI2_GPIO GPIOB #define SPI2_NSS_PIN PB12
#define SPI2_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB #define SPI2_SCK_PIN PB13
#define SPI2_NSS_PIN Pin_12 #define SPI2_MISO_PIN PB14
#define SPI2_NSS_PIN_SOURCE GPIO_PinSource12 #define SPI2_MOSI_PIN PB15
#define SPI2_SCK_PIN Pin_13
#define SPI2_SCK_PIN_SOURCE GPIO_PinSource13
#define SPI2_MISO_PIN Pin_14
#define SPI2_MISO_PIN_SOURCE GPIO_PinSource14
#define SPI2_MOSI_PIN Pin_15
#define SPI2_MOSI_PIN_SOURCE GPIO_PinSource15
#ifdef FURYF3_SPIFLASH #ifdef FURYF3_SPIFLASH
#define USE_FLASHFS #define USE_FLASHFS
@ -88,8 +78,7 @@
#ifdef USE_FLASHFS #ifdef USE_FLASHFS
#define USE_FLASH_M25P16 #define USE_FLASH_M25P16
#define M25P16_CS_GPIO GPIOB #define M25P16_CS_PIN PB12
#define M25P16_CS_PIN GPIO_Pin_12
#define M25P16_SPI_INSTANCE SPI2 #define M25P16_SPI_INSTANCE SPI2
#define ENABLE_BLACKBOX_LOGGING_ON_SPIFLASH_BY_DEFAULT #define ENABLE_BLACKBOX_LOGGING_ON_SPIFLASH_BY_DEFAULT
#endif #endif
@ -99,11 +88,9 @@
#define SDCARD_DETECT_INVERTED #define SDCARD_DETECT_INVERTED
#define SDCARD_DETECT_PIN GPIO_Pin_2 #define SDCARD_DETECT_PIN PB2
#define SDCARD_DETECT_EXTI_LINE EXTI_Line2 #define SDCARD_DETECT_EXTI_LINE EXTI_Line2
#define SDCARD_DETECT_EXTI_PIN_SOURCE EXTI_PinSource2 #define SDCARD_DETECT_EXTI_PIN_SOURCE EXTI_PinSource2
#define SDCARD_DETECT_GPIO_PORT GPIOB
#define SDCARD_DETECT_GPIO_CLK RCC_AHBPeriph_GPIOB
#define SDCARD_DETECT_EXTI_PORT_SOURCE EXTI_PortSourceGPIOB #define SDCARD_DETECT_EXTI_PORT_SOURCE EXTI_PortSourceGPIOB
#define SDCARD_DETECT_EXTI_IRQn EXTI15_10_IRQn #define SDCARD_DETECT_EXTI_IRQn EXTI15_10_IRQn
@ -116,7 +103,7 @@
// Divide to under 25MHz for normal operation: // Divide to under 25MHz for normal operation:
#define SDCARD_SPI_FULL_SPEED_CLOCK_DIVIDER 2 #define SDCARD_SPI_FULL_SPEED_CLOCK_DIVIDER 2
// Note, this is the same DMA channel as USART1_RX. Luckily we don't use DMA for USART Rx. // Note, this is the same DMA channel as UART1_RX. Luckily we don't use DMA for USART Rx.
#define SDCARD_DMA_CHANNEL_TX DMA1_Channel5 #define SDCARD_DMA_CHANNEL_TX DMA1_Channel5
#define SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG DMA1_FLAG_TC5 #define SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG DMA1_FLAG_TC5
#endif #endif

22
src/main/target/LUX_RACE/target.h
View file

@ -30,26 +30,20 @@
#define USE_EXTI #define USE_EXTI
#define MPU_INT_EXTI PA5 #define MPU_INT_EXTI PA5
#define EXTI_CALLBACK_HANDLER_COUNT 1 // MPU data ready #define EXTI_CALLBACK_HANDLER_COUNT 1 // MPU data ready
//#define DEBUG_MPU_DATA_READY_INTERRUPT
#define USE_MPU_DATA_READY_SIGNAL #define USE_MPU_DATA_READY_SIGNAL
#define ENSURE_MPU_DATA_READY_IS_LOW #define ENSURE_MPU_DATA_READY_IS_LOW
//#define DEBUG_MPU_DATA_READY_INTERRUPT
#define MPU6500_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOA
#define MPU6500_CS_GPIO GPIOA
#define MPU6500_CS_PIN GPIO_Pin_4
#define MPU6500_SPI_INSTANCE SPI1
#define USE_SPI #define USE_SPI
#define USE_SPI_DEVICE_1 #define USE_SPI_DEVICE_1
#define SPI1_GPIO GPIOB #define SPI1_SCK_PIN PB3
#define SPI1_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB #define SPI1_MISO_PIN PB4
#define SPI1_SCK_PIN GPIO_Pin_3 #define SPI1_MOSI_PIN PB5
#define SPI1_SCK_PIN_SOURCE GPIO_PinSource3 #define SPI1_NSS_PIN PA4
#define SPI1_MISO_PIN GPIO_Pin_4
#define SPI1_MISO_PIN_SOURCE GPIO_PinSource4 #define MPU6500_CS_PIN SPI1_NSS_PIN
#define SPI1_MOSI_PIN GPIO_Pin_5 #define MPU6500_SPI_INSTANCE SPI1
#define SPI1_MOSI_PIN_SOURCE GPIO_PinSource5
#define GYRO #define GYRO
#define USE_GYRO_MPU6500 #define USE_GYRO_MPU6500

22
src/main/target/MOTOLAB/target.h
View file

@ -40,6 +40,15 @@
#define USE_ACC_MPU6050 #define USE_ACC_MPU6050
#define ACC_MPU6050_ALIGN CW180_DEG #define ACC_MPU6050_ALIGN CW180_DEG
#define USE_GYRO_SPI_MPU6000
#define GYRO_MPU6000_ALIGN CW180_DEG
#define USE_ACC_SPI_MPU6000
#define ACC_MPU6000_ALIGN CW180_DEG
#define MPU6000_CS_GPIO GPIOB
#define MPU6000_CS_PIN PB12
#define MPU6000_SPI_INSTANCE SPI2
//#define BARO //#define BARO
//#define USE_BARO_MS5611 //#define USE_BARO_MS5611
@ -69,16 +78,11 @@
#define USE_SPI #define USE_SPI
#define USE_SPI_DEVICE_2 #define USE_SPI_DEVICE_2
#define M25P16_CS_GPIO GPIOB #define M25P16_CS_PIN PB12
#define M25P16_CS_PIN GPIO_Pin_12 #define M25P16_SPI_INSTANCE SPI2
#define M25P16_SPI_INSTANCE SPI2
#define MPU6000_CS_GPIO GPIOB //#define SENSORS_SET (SENSOR_ACC | SENSOR_BARO | SENSOR_GPS | SENSOR_MAG)
#define MPU6000_CS_PIN GPIO_Pin_12 #define SENSORS_SET (SENSOR_ACC)
#define MPU6000_SPI_INSTANCE SPI2
//#define SENSORS_SET (SENSOR_ACC | SENSOR_BARO | SENSOR_GPS | SENSOR_MAG)
#define SENSORS_SET (SENSOR_ACC)
#define USE_FLASHFS #define USE_FLASHFS
#define USE_FLASH_M25P16 #define USE_FLASH_M25P16

10
src/main/target/NAZE/hardware_revision.c
View file

@ -53,8 +53,8 @@ void detectHardwareRevision(void)
#ifdef USE_SPI #ifdef USE_SPI
#define DISABLE_SPI_CS GPIO_SetBits(NAZE_SPI_CS_GPIO, NAZE_SPI_CS_PIN) #define DISABLE_SPI_CS IOHi(nazeSpiCsPin)
#define ENABLE_SPI_CS GPIO_ResetBits(NAZE_SPI_CS_GPIO, NAZE_SPI_CS_PIN) #define ENABLE_SPI_CS IOLo(nazeSpiCsPin)
#define SPI_DEVICE_NONE (0) #define SPI_DEVICE_NONE (0)
#define SPI_DEVICE_FLASH (1) #define SPI_DEVICE_FLASH (1)
@ -63,8 +63,14 @@ void detectHardwareRevision(void)
#define M25P16_INSTRUCTION_RDID 0x9F #define M25P16_INSTRUCTION_RDID 0x9F
#define FLASH_M25P16_ID (0x202015) #define FLASH_M25P16_ID (0x202015)
static IO_t nazeSpiCsPin = IO_NONE;
uint8_t detectSpiDevice(void) uint8_t detectSpiDevice(void)
{ {
#ifdef NAZE_SPI_CS_PIN
nazeSpiCsPin = IOGetByTag(IO_TAG(NAZE_SPI_CS_PIN));
#endif
uint8_t out[] = { M25P16_INSTRUCTION_RDID, 0, 0, 0 }; 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;

19
src/main/target/NAZE/target.h
View file

@ -54,7 +54,7 @@
#define NAZE_SPI_INSTANCE SPI2 #define NAZE_SPI_INSTANCE SPI2
#define NAZE_SPI_CS_GPIO GPIOB #define NAZE_SPI_CS_GPIO GPIOB
#define NAZE_SPI_CS_PIN GPIO_Pin_12 #define NAZE_SPI_CS_PIN PB12
#define NAZE_CS_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOB #define NAZE_CS_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOB
// We either have this 16mbit flash chip on SPI or the MPU6500 acc/gyro depending on board revision: // We either have this 16mbit flash chip on SPI or the MPU6500 acc/gyro depending on board revision:
@ -105,7 +105,7 @@
//#define USE_MAG_MAG3110 //#define USE_MAG_MAG3110
#define MAG_HMC5883_ALIGN CW180_DEG #define MAG_HMC5883_ALIGN CW180_DEG
#define SONAR //#define SONAR
//#define USE_SONAR_SRF10 //#define USE_SONAR_SRF10
#define SONAR_TRIGGER_PIN PB0 #define SONAR_TRIGGER_PIN PB0
#define SONAR_ECHO_PIN PB1 #define SONAR_ECHO_PIN PB1
@ -166,18 +166,13 @@
// RC10 PB1/TIM3 MOSI /softserial2 TX / sonar echo / current // RC10 PB1/TIM3 MOSI /softserial2 TX / sonar echo / current
// Nordic Semiconductor uses 'CSN', STM uses 'NSS' // Nordic Semiconductor uses 'CSN', STM uses 'NSS'
#define NRF24_CE_GPIO GPIOA #define NRF24_CE_PIN PA1
#define NRF24_CE_PIN GPIO_Pin_1
#define NRF24_CE_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA #define NRF24_CE_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define NRF24_CSN_GPIO GPIOA #define NRF24_CSN_PIN PA6
#define NRF24_CSN_PIN GPIO_Pin_6
#define NRF24_CSN_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA #define NRF24_CSN_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOA
#define NRF24_SCK_GPIO GPIOA #define NRF24_SCK_PIN PA7
#define NRF24_SCK_PIN GPIO_Pin_7 #define NRF24_MOSI_PIN PB1
#define NRF24_MOSI_GPIO GPIOB #define NRF24_MISO_PIN PB0
#define NRF24_MOSI_PIN GPIO_Pin_1
#define NRF24_MISO_GPIO GPIOB
#define NRF24_MISO_PIN GPIO_Pin_0
#endif // USE_NRF24 #endif // USE_NRF24
#define USE_ADC #define USE_ADC

21
src/main/target/PORT103R/target.h
View file

@ -35,23 +35,18 @@
#define USE_SPI #define USE_SPI
#define USE_SPI_DEVICE_2 #define USE_SPI_DEVICE_2
#define PORT103R_SPI_INSTANCE SPI2 #define PORT103R_SPI_INSTANCE SPI2
#define PORT103R_SPI_CS_GPIO GPIOB #define PORT103R_SPI_CS_PIN PB12
#define PORT103R_SPI_CS_PIN GPIO_Pin_12
// We either have this 16mbit flash chip on SPI or the MPU6500 acc/gyro depending on board revision: // We either have this 16mbit flash chip on SPI or the MPU6500 acc/gyro depending on board revision:
#define M25P16_CS_GPIO PORT103R_SPI_CS_GPIO #define M25P16_CS_PIN PORT103R_SPI_CS_PIN
#define M25P16_CS_PIN PORT103R_SPI_CS_PIN #define M25P16_SPI_INSTANCE PORT103R_SPI_INSTANCE
#define M25P16_SPI_INSTANCE PORT103R_SPI_INSTANCE
#define MPU6000_CS_GPIO PORT103R_SPI_CS_GPIO #define MPU6000_CS_PIN PORT103R_SPI_CS_PIN
#define MPU6000_CS_PIN PORT103R_SPI_CS_PIN #define MPU6000_SPI_INSTANCE PORT103R_SPI_INSTANCE
#define MPU6000_SPI_INSTANCE PORT103R_SPI_INSTANCE
#define MPU6500_CS_GPIO PORT103R_SPI_CS_GPIO #define MPU6500_CS_PIN PORT103R_SPI_CS_PIN
#define MPU6500_CS_PIN PORT103R_SPI_CS_PIN #define MPU6500_SPI_INSTANCE PORT103R_SPI_INSTANCE
#define MPU6500_SPI_INSTANCE PORT103R_SPI_INSTANCE
#define MPU6500_CS_GPIO_CLK_PERIPHERAL RCC_APB2Periph_GPIOB
#define GYRO #define GYRO
#define USE_FAKE_GYRO #define USE_FAKE_GYRO

13
src/main/target/RMDO/target.h
View file

@ -83,19 +83,8 @@
#define USE_SPI #define USE_SPI
#define USE_SPI_DEVICE_2 // PB12,13,14,15 on AF5 #define USE_SPI_DEVICE_2 // PB12,13,14,15 on AF5
#define SPI2_GPIO GPIOB
#define SPI2_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB
#define SPI2_NSS_PIN Pin_12
#define SPI2_NSS_PIN_SOURCE GPIO_PinSource12
#define SPI2_SCK_PIN Pin_13
#define SPI2_SCK_PIN_SOURCE GPIO_PinSource13
#define SPI2_MISO_PIN Pin_14
#define SPI2_MISO_PIN_SOURCE GPIO_PinSource14
#define SPI2_MOSI_PIN Pin_15
#define SPI2_MOSI_PIN_SOURCE GPIO_PinSource15
#define M25P16_CS_GPIO GPIOB #define M25P16_CS_GPIO GPIOB
#define M25P16_CS_PIN GPIO_Pin_12 #define M25P16_CS_PIN PB12
#define M25P16_SPI_INSTANCE SPI2 #define M25P16_SPI_INSTANCE SPI2
#define BOARD_HAS_VOLTAGE_DIVIDER #define BOARD_HAS_VOLTAGE_DIVIDER

14
src/main/target/SPRACINGF3/target.h
View file

@ -89,19 +89,7 @@
#define USE_SPI #define USE_SPI
#define USE_SPI_DEVICE_2 // PB12,13,14,15 on AF5 #define USE_SPI_DEVICE_2 // PB12,13,14,15 on AF5
#define SPI2_GPIO GPIOB #define M25P16_CS_PIN PB12
#define SPI2_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB
#define SPI2_NSS_PIN Pin_12
#define SPI2_NSS_PIN_SOURCE GPIO_PinSource12
#define SPI2_SCK_PIN Pin_13
#define SPI2_SCK_PIN_SOURCE GPIO_PinSource13
#define SPI2_MISO_PIN Pin_14
#define SPI2_MISO_PIN_SOURCE GPIO_PinSource14
#define SPI2_MOSI_PIN Pin_15
#define SPI2_MOSI_PIN_SOURCE GPIO_PinSource15
#define M25P16_CS_GPIO GPIOB
#define M25P16_CS_PIN GPIO_Pin_12
#define M25P16_SPI_INSTANCE SPI2 #define M25P16_SPI_INSTANCE SPI2
#define BOARD_HAS_VOLTAGE_DIVIDER #define BOARD_HAS_VOLTAGE_DIVIDER

45
src/main/target/SPRACINGF3EVO/target.h
View file

@ -82,43 +82,23 @@
#define USE_SPI_DEVICE_1 // PB9,3,4,5 on AF5 SPI1 (MPU) #define USE_SPI_DEVICE_1 // PB9,3,4,5 on AF5 SPI1 (MPU)
#define USE_SPI_DEVICE_2 // PB12,13,14,15 on AF5 SPI2 (SDCard) #define USE_SPI_DEVICE_2 // PB12,13,14,15 on AF5 SPI2 (SDCard)
#define SPI1_GPIO GPIOB #define SPI1_NSS_PIN PB9
#define SPI1_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB #define SPI1_SCK_PIN PB3
#define SPI1_NSS_PIN Pin_9 #define SPI1_MISO_PIN PB4
#define SPI1_NSS_PIN_SOURCE GPIO_PinSource9 #define SPI1_MOSI_PIN PB5
#define SPI1_SCK_PIN Pin_3
#define SPI1_SCK_PIN_SOURCE GPIO_PinSource3
#define SPI1_MISO_PIN Pin_4
#define SPI1_MISO_PIN_SOURCE GPIO_PinSource4
#define SPI1_MOSI_PIN Pin_5
#define SPI1_MOSI_PIN_SOURCE GPIO_PinSource5
#define SPI2_GPIO GPIOB #define SPI2_NSS_PIN PB12
#define SPI2_GPIO_PERIPHERAL RCC_AHBPeriph_GPIOB #define SPI2_SCK_PIN PB13
#define SPI2_NSS_PIN Pin_12 #define SPI2_MISO_PIN PB14
#define SPI2_NSS_PIN_SOURCE GPIO_PinSource12 #define SPI2_MOSI_PIN PB15
#define SPI2_SCK_PIN Pin_13
#define SPI2_SCK_PIN_SOURCE GPIO_PinSource13
#define SPI2_MISO_PIN Pin_14
#define SPI2_MISO_PIN_SOURCE GPIO_PinSource14
#define SPI2_MOSI_PIN Pin_15
#define SPI2_MOSI_PIN_SOURCE GPIO_PinSource15
#define USE_SDCARD #define USE_SDCARD
#define USE_SDCARD_SPI2 #define USE_SDCARD_SPI2
#define SDCARD_DETECT_INVERTED #define SDCARD_DETECT_INVERTED
#define SDCARD_DETECT_PIN GPIO_Pin_14 #define SDCARD_DETECT_PIN PC14
#define SDCARD_DETECT_EXTI_LINE EXTI_Line14
#define SDCARD_DETECT_EXTI_PIN_SOURCE EXTI_PinSource14
#define SDCARD_DETECT_GPIO_PORT GPIOC
#define SDCARD_DETECT_GPIO_CLK RCC_AHBPeriph_GPIOC
#define SDCARD_DETECT_EXTI_PORT_SOURCE EXTI_PortSourceGPIOC
#define SDCARD_DETECT_EXTI_IRQn EXTI15_10_IRQn
#define SDCARD_SPI_INSTANCE SPI2 #define SDCARD_SPI_INSTANCE SPI2
#define SDCARD_SPI_CS_GPIO SPI2_GPIO
#define SDCARD_SPI_CS_PIN SPI2_NSS_PIN #define SDCARD_SPI_CS_PIN SPI2_NSS_PIN
// SPI2 is on the APB1 bus whose clock runs at 36MHz. Divide to under 400kHz for init: // SPI2 is on the APB1 bus whose clock runs at 36MHz. Divide to under 400kHz for init:
@ -126,14 +106,11 @@
// Divide to under 25MHz for normal operation: // Divide to under 25MHz for normal operation:
#define SDCARD_SPI_FULL_SPEED_CLOCK_DIVIDER 2 #define SDCARD_SPI_FULL_SPEED_CLOCK_DIVIDER 2
// Note, this is the same DMA channel as USART1_RX. Luckily we don't use DMA for USART Rx. // Note, this is the same DMA channel as UART1_RX. Luckily we don't use DMA for USART Rx.
#define SDCARD_DMA_CHANNEL_TX DMA1_Channel5 #define SDCARD_DMA_CHANNEL_TX DMA1_Channel5
#define SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG DMA1_FLAG_TC5 #define SDCARD_DMA_CHANNEL_TX_COMPLETE_FLAG DMA1_FLAG_TC5
#define MPU6500_CS_PIN PB9
#define MPU6500_CS_GPIO_CLK_PERIPHERAL SPI1_GPIO_PERIPHERAL
#define MPU6500_CS_GPIO SPI1_GPIO
#define MPU6500_CS_PIN GPIO_Pin_9
#define MPU6500_SPI_INSTANCE SPI1 #define MPU6500_SPI_INSTANCE SPI1
#define USE_ADC #define USE_ADC

23
src/main/target/STM32F3DISCOVERY/target.h
View file

@ -31,18 +31,29 @@
#define USE_SPI_DEVICE_1 #define USE_SPI_DEVICE_1
#define USE_SPI_DEVICE_2 #define USE_SPI_DEVICE_2
#define SPI2_NSS_PIN PB12
#define SPI2_SCK_PIN PB13
#define SPI2_MISO_PIN PB14
#define SPI2_MOSI_PIN PB15
#define GYRO #define GYRO
#define USE_GYRO_L3GD20 #define USE_GYRO_L3GD20
#define L3GD20_SPI SPI1
#define L3GD20_SPI SPI1 #define L3GD20_CS_PIN PE3
#define L3GD20_CS_GPIO_CLK_PERIPHERAL RCC_AHBPeriph_GPIOE
#define L3GD20_CS_GPIO GPIOE
#define L3GD20_CS_PIN GPIO_Pin_3
#define GYRO_L3GD20_ALIGN CW270_DEG #define GYRO_L3GD20_ALIGN CW270_DEG
// Support the GY-91 MPU9250 dev board
#define USE_GYRO_MPU6500
#define USE_GYRO_SPI_MPU6500
#define MPU6500_CS_PIN PC14
#define MPU6500_SPI_INSTANCE SPI2
#define GYRO_MPU6500_ALIGN CW270_DEG_FLIP
#define ACC #define ACC
#define USE_ACC_LSM303DLHC #define USE_ACC_LSM303DLHC
#define USE_ACC_MPU6500
#define USE_ACC_SPI_MPU6500
#define ACC_MPU6500_ALIGN CW270_DEG_FLIP
#define MAG #define MAG
#define USE_MAG_HMC5883 #define USE_MAG_HMC5883

1
src/main/target/STM32F3DISCOVERY/target.mk
View file

@ -12,6 +12,7 @@ TARGET_SRC = \
drivers/accgyro_mpu3050.c \ drivers/accgyro_mpu3050.c \
drivers/accgyro_mpu6050.c \ drivers/accgyro_mpu6050.c \
drivers/accgyro_mpu6500.c \ drivers/accgyro_mpu6500.c \
drivers/accgyro_spi_mpu6500.c \
drivers/barometer_bmp280.c \ drivers/barometer_bmp280.c \
drivers/barometer_ms5611.c \ drivers/barometer_ms5611.c \
drivers/compass_ak8975.c \ drivers/compass_ak8975.c \