diff --git a/src/main/drivers/accgyro_l3gd20.c b/src/main/drivers/accgyro_l3gd20.c index 7b14634b0..dd28aceb1 100644 --- a/src/main/drivers/accgyro_l3gd20.c +++ b/src/main/drivers/accgyro_l3gd20.c @@ -81,7 +81,7 @@ static void l3gd20SpiInit(SPI_TypeDef *SPIx) DISABLE_L3GD20; - spiSetDivisor(L3GD20_SPI, SPI_9MHZ_CLOCK_DIVIDER); + spiSetDivisor(L3GD20_SPI, SPI_CLOCK_STANDARD); } void l3gd20GyroInit(uint8_t lpf) diff --git a/src/main/drivers/accgyro_spi_mpu6000.c b/src/main/drivers/accgyro_spi_mpu6000.c index 56143f0e4..3d58913d0 100644 --- a/src/main/drivers/accgyro_spi_mpu6000.c +++ b/src/main/drivers/accgyro_spi_mpu6000.c @@ -128,13 +128,13 @@ void mpu6000SpiGyroInit(uint8_t lpf) mpu6000AccAndGyroInit(); - spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_0_5625MHZ_CLOCK_DIVIDER); + spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_INITIALIZATON); // Accel and Gyro DLPF Setting mpu6000WriteRegister(MPU6000_CONFIG, lpf); delayMicroseconds(1); - spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_18MHZ_CLOCK_DIVIDER); // 18 MHz SPI clock + spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_FAST); // 18 MHz SPI clock int16_t data[3]; mpuGyroRead(data); @@ -162,7 +162,7 @@ bool mpu6000SpiDetect(void) IOInit(mpuSpi6000CsPin, OWNER_SYSTEM, RESOURCE_SPI); IOConfigGPIO(mpuSpi6000CsPin, SPI_IO_CS_CFG); - spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_0_5625MHZ_CLOCK_DIVIDER); + spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_INITIALIZATON); mpu6000WriteRegister(MPU_RA_PWR_MGMT_1, BIT_H_RESET); @@ -209,7 +209,7 @@ static void mpu6000AccAndGyroInit(void) { return; } - spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_0_5625MHZ_CLOCK_DIVIDER); + spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_INITIALIZATON); // Device Reset mpu6000WriteRegister(MPU_RA_PWR_MGMT_1, BIT_H_RESET); @@ -251,7 +251,7 @@ static void mpu6000AccAndGyroInit(void) { delayMicroseconds(15); #endif - spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_18MHZ_CLOCK_DIVIDER); // 18 MHz SPI clock + spiSetDivisor(MPU6000_SPI_INSTANCE, SPI_CLOCK_FAST); delayMicroseconds(1); mpuSpi6000InitDone = true; diff --git a/src/main/drivers/accgyro_spi_mpu6500.c b/src/main/drivers/accgyro_spi_mpu6500.c index 316a296c3..4df65c19c 100755 --- a/src/main/drivers/accgyro_spi_mpu6500.c +++ b/src/main/drivers/accgyro_spi_mpu6500.c @@ -72,11 +72,7 @@ static void mpu6500SpiInit(void) IOInit(mpuSpi6500CsPin, OWNER_SYSTEM, RESOURCE_SPI); IOConfigGPIO(mpuSpi6500CsPin, SPI_IO_CS_CFG); -#if defined(STM32F4) - spiSetDivisor(MPU6500_SPI_INSTANCE, SPI_SLOW_CLOCK); -#else - spiSetDivisor(MPU6500_SPI_INSTANCE, SPI_STANDARD_CLOCK); -#endif + spiSetDivisor(MPU6500_SPI_INSTANCE, SPI_CLOCK_FAST); hardwareInitialised = true; } diff --git a/src/main/drivers/accgyro_spi_mpu9250.c b/src/main/drivers/accgyro_spi_mpu9250.c index 2721d0559..2bad53bf3 100644 --- a/src/main/drivers/accgyro_spi_mpu9250.c +++ b/src/main/drivers/accgyro_spi_mpu9250.c @@ -55,7 +55,8 @@ static IO_t mpuSpi9250CsPin = IO_NONE; #define DISABLE_MPU9250 IOHi(mpuSpi9250CsPin) #define ENABLE_MPU9250 IOLo(mpuSpi9250CsPin) -void mpu9250ResetGyro(void) { +void mpu9250ResetGyro(void) +{ // Device Reset mpu9250WriteRegister(MPU_RA_PWR_MGMT_1, MPU9250_BIT_RESET); delay(150); @@ -105,7 +106,7 @@ void mpu9250SpiGyroInit(uint8_t lpf) spiResetErrorCounter(MPU9250_SPI_INSTANCE); - spiSetDivisor(MPU9250_SPI_INSTANCE, 5); //high speed now that we don't need to write to the slow registers + spiSetDivisor(MPU9250_SPI_INSTANCE, SPI_CLOCK_FAST); //high speed now that we don't need to write to the slow registers int16_t data[3]; mpuGyroRead(data); @@ -123,9 +124,8 @@ void mpu9250SpiAccInit(acc_t *acc) acc->acc_1G = 512 * 8; } - -bool verifympu9250WriteRegister(uint8_t reg, uint8_t data) { - +bool verifympu9250WriteRegister(uint8_t reg, uint8_t data) +{ uint8_t in; uint8_t attemptsRemaining = 20; @@ -151,7 +151,7 @@ static void mpu9250AccAndGyroInit(uint8_t lpf) { return; } - spiSetDivisor(MPU9250_SPI_INSTANCE, SPI_SLOW_CLOCK); //low speed for writing to slow registers + spiSetDivisor(MPU9250_SPI_INSTANCE, SPI_CLOCK_INITIALIZATON); //low speed for writing to slow registers mpu9250WriteRegister(MPU_RA_PWR_MGMT_1, MPU9250_BIT_RESET); delay(50); @@ -177,6 +177,8 @@ static void mpu9250AccAndGyroInit(uint8_t lpf) { verifympu9250WriteRegister(MPU_RA_INT_ENABLE, 0x01); //this resets register MPU_RA_PWR_MGMT_1 and won't read back correctly. #endif + spiSetDivisor(MPU9250_SPI_INSTANCE, SPI_CLOCK_FAST); + mpuSpi9250InitDone = true; //init done } @@ -192,7 +194,7 @@ bool mpu9250SpiDetect(void) IOInit(mpuSpi9250CsPin, OWNER_SYSTEM, RESOURCE_SPI); IOConfigGPIO(mpuSpi9250CsPin, SPI_IO_CS_CFG); - spiSetDivisor(MPU9250_SPI_INSTANCE, SPI_SLOW_CLOCK); //low speed + spiSetDivisor(MPU9250_SPI_INSTANCE, SPI_CLOCK_INITIALIZATON); //low speed mpu9250WriteRegister(MPU_RA_PWR_MGMT_1, MPU9250_BIT_RESET); do { @@ -207,6 +209,8 @@ bool mpu9250SpiDetect(void) } } while (attemptsRemaining--); + spiSetDivisor(MPU9250_SPI_INSTANCE, SPI_CLOCK_FAST); + return true; } diff --git a/src/main/drivers/barometer_spi_bmp280.c b/src/main/drivers/barometer_spi_bmp280.c index 0e047383a..f3747ef02 100644 --- a/src/main/drivers/barometer_spi_bmp280.c +++ b/src/main/drivers/barometer_spi_bmp280.c @@ -87,7 +87,7 @@ void bmp280SpiInit(void) GPIO_SetBits(BMP280_CS_GPIO, BMP280_CS_PIN); - spiSetDivisor(BMP280_SPI_INSTANCE, SPI_9MHZ_CLOCK_DIVIDER); + spiSetDivisor(BMP280_SPI_INSTANCE, SPI_CLOCK_STANDARD); hardwareInitialised = true; } diff --git a/src/main/drivers/bus_spi.c b/src/main/drivers/bus_spi.c index 5af40d075..c78c2024a 100644 --- a/src/main/drivers/bus_spi.c +++ b/src/main/drivers/bus_spi.c @@ -36,7 +36,7 @@ #define GPIO_AF_SPI2 GPIO_AF_5 #endif #ifndef GPIO_AF_SPI3 -#define GPIO_AF_SPI3 GPIO_AF_6 +#define GPIO_AF_SPI3 GPIO_AF_6 #endif #endif @@ -72,169 +72,169 @@ #endif static spiDevice_t spiHardwareMap[] = { -#if defined(STM32F10X) - { .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 }, +#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 }, + { .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(STM32F303xC) || defined(STM32F40_41xxx) || defined(STM32F411xE) - { .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 } +#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) { - if (instance == SPI1) - return SPIDEV_1; + if (instance == SPI1) + return SPIDEV_1; - if (instance == SPI2) - return SPIDEV_2; + if (instance == SPI2) + return SPIDEV_2; - if (instance == SPI3) - return SPIDEV_3; + if (instance == SPI3) + return SPIDEV_3; - return SPIINVALID; + return SPIINVALID; } void spiInitDevice(SPIDevice device) { - SPI_InitTypeDef spiInit; + SPI_InitTypeDef spiInit; - spiDevice_t *spi = &(spiHardwareMap[device]); + spiDevice_t *spi = &(spiHardwareMap[device]); #ifdef SDCARD_SPI_INSTANCE - if (spi->dev == SDCARD_SPI_INSTANCE) - spi->sdcard = true; + if (spi->dev == SDCARD_SPI_INSTANCE) + spi->sdcard = true; #endif - // Enable SPI clock - RCC_ClockCmd(spi->rcc, ENABLE); - RCC_ResetCmd(spi->rcc, ENABLE); + // Enable SPI clock + RCC_ClockCmd(spi->rcc, ENABLE); + RCC_ResetCmd(spi->rcc, ENABLE); - IOInit(IOGetByTag(spi->sck), OWNER_SYSTEM, RESOURCE_SPI); - IOInit(IOGetByTag(spi->miso), OWNER_SYSTEM, RESOURCE_SPI); - IOInit(IOGetByTag(spi->mosi), OWNER_SYSTEM, RESOURCE_SPI); + IOInit(IOGetByTag(spi->sck), OWNER_SYSTEM, RESOURCE_SPI); + IOInit(IOGetByTag(spi->miso), OWNER_SYSTEM, RESOURCE_SPI); + IOInit(IOGetByTag(spi->mosi), OWNER_SYSTEM, RESOURCE_SPI); #if defined(STM32F303xC) || defined(STM32F4) - if (spi->sdcard) { - IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG, spi->af); - IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_MISO_CFG, spi->af); - } - else { - IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_CFG, spi->af); - IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_CFG, spi->af); - } - IOConfigGPIOAF(IOGetByTag(spi->mosi), SPI_IO_AF_CFG, spi->af); + if (spi->sdcard) { + IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_SCK_CFG, spi->af); + IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_MISO_CFG, spi->af); + } + else { + IOConfigGPIOAF(IOGetByTag(spi->sck), SPI_IO_AF_CFG, spi->af); + IOConfigGPIOAF(IOGetByTag(spi->miso), SPI_IO_AF_CFG, spi->af); + } + IOConfigGPIOAF(IOGetByTag(spi->mosi), SPI_IO_AF_CFG, spi->af); - if (spi->nss) - IOConfigGPIOAF(IOGetByTag(spi->nss), SPI_IO_CS_CFG, spi->af); + if (spi->nss) + IOConfigGPIOAF(IOGetByTag(spi->nss), SPI_IO_CS_CFG, spi->af); #endif #if defined(STM32F10X) - IOConfigGPIO(IOGetByTag(spi->sck), SPI_IO_AF_CFG); - IOConfigGPIO(IOGetByTag(spi->miso), SPI_IO_AF_CFG); - IOConfigGPIO(IOGetByTag(spi->mosi), SPI_IO_AF_CFG); + IOConfigGPIO(IOGetByTag(spi->sck), SPI_IO_AF_CFG); + IOConfigGPIO(IOGetByTag(spi->miso), SPI_IO_AF_CFG); + IOConfigGPIO(IOGetByTag(spi->mosi), SPI_IO_AF_CFG); - if (spi->nss) - IOConfigGPIO(IOGetByTag(spi->nss), SPI_IO_CS_CFG); + if (spi->nss) + IOConfigGPIO(IOGetByTag(spi->nss), SPI_IO_CS_CFG); #endif - // Init SPI hardware - SPI_I2S_DeInit(spi->dev); + // Init SPI hardware + SPI_I2S_DeInit(spi->dev); - spiInit.SPI_Mode = SPI_Mode_Master; - spiInit.SPI_Direction = SPI_Direction_2Lines_FullDuplex; - 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; + spiInit.SPI_Mode = SPI_Mode_Master; + spiInit.SPI_Direction = SPI_Direction_2Lines_FullDuplex; + 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; - if (spi->sdcard) { - spiInit.SPI_CPOL = SPI_CPOL_Low; - spiInit.SPI_CPHA = SPI_CPHA_1Edge; - } - else { - spiInit.SPI_CPOL = SPI_CPOL_High; - spiInit.SPI_CPHA = SPI_CPHA_2Edge; - } + if (spi->sdcard) { + spiInit.SPI_CPOL = SPI_CPOL_Low; + spiInit.SPI_CPHA = SPI_CPHA_1Edge; + } + else { + spiInit.SPI_CPOL = SPI_CPOL_High; + spiInit.SPI_CPHA = SPI_CPHA_2Edge; + } #ifdef STM32F303xC - // Configure for 8-bit reads. - SPI_RxFIFOThresholdConfig(spi->dev, SPI_RxFIFOThreshold_QF); + // Configure for 8-bit reads. + SPI_RxFIFOThresholdConfig(spi->dev, SPI_RxFIFOThreshold_QF); #endif - SPI_Init(spi->dev, &spiInit); - SPI_Cmd(spi->dev, ENABLE); + SPI_Init(spi->dev, &spiInit); + SPI_Cmd(spi->dev, ENABLE); - if (spi->nss) - IOHi(IOGetByTag(spi->nss)); + if (spi->nss) + IOHi(IOGetByTag(spi->nss)); } bool spiInit(SPIDevice device) { - switch (device) - { - case SPIINVALID: - return false; - case SPIDEV_1: + switch (device) + { + case SPIINVALID: + return false; + case SPIDEV_1: #ifdef USE_SPI_DEVICE_1 - spiInitDevice(device); - return true; + spiInitDevice(device); + return true; #else - break; + break; #endif - case SPIDEV_2: + case SPIDEV_2: #ifdef USE_SPI_DEVICE_2 - spiInitDevice(device); - return true; + spiInitDevice(device); + return true; #else - break; + break; #endif - case SPIDEV_3: + case SPIDEV_3: #if defined(USE_SPI_DEVICE_3) && (defined(STM32F303xC) || defined(STM32F4)) - spiInitDevice(device); - return true; + spiInitDevice(device); + return true; #else - break; + 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; + 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) { - uint16_t spiTimeout = 1000; + uint16_t spiTimeout = 1000; - while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) - if ((spiTimeout--) == 0) - return spiTimeoutUserCallback(instance); + while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) + if ((spiTimeout--) == 0) + return spiTimeoutUserCallback(instance); #ifdef STM32F303xC - SPI_SendData8(instance, data); + SPI_SendData8(instance, data); #else - SPI_I2S_SendData(instance, data); + SPI_I2S_SendData(instance, data); #endif - spiTimeout = 1000; - while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET) - if ((spiTimeout--) == 0) - return spiTimeoutUserCallback(instance); + spiTimeout = 1000; + while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET) + if ((spiTimeout--) == 0) + return spiTimeoutUserCallback(instance); #ifdef STM32F303xC - return ((uint8_t)SPI_ReceiveData8(instance)); + return ((uint8_t)SPI_ReceiveData8(instance)); #else - return ((uint8_t)SPI_I2S_ReceiveData(instance)); + return ((uint8_t)SPI_I2S_ReceiveData(instance)); #endif } @@ -244,118 +244,115 @@ uint8_t spiTransferByte(SPI_TypeDef *instance, uint8_t data) bool spiIsBusBusy(SPI_TypeDef *instance) { #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; #else - 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 } bool spiTransfer(SPI_TypeDef *instance, uint8_t *out, const uint8_t *in, int len) { - uint16_t spiTimeout = 1000; + uint16_t spiTimeout = 1000; - uint8_t b; - instance->DR; - while (len--) { - b = in ? *(in++) : 0xFF; - while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) { - if ((spiTimeout--) == 0) - return spiTimeoutUserCallback(instance); - } + uint8_t b; + instance->DR; + while (len--) { + b = in ? *(in++) : 0xFF; + while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_TXE) == RESET) { + if ((spiTimeout--) == 0) + return spiTimeoutUserCallback(instance); + } #ifdef STM32F303xC - SPI_SendData8(instance, b); - //SPI_I2S_SendData16(instance, b); + SPI_SendData8(instance, b); #else - SPI_I2S_SendData(instance, b); + SPI_I2S_SendData(instance, b); #endif - spiTimeout = 1000; - while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET) { - if ((spiTimeout--) == 0) - return spiTimeoutUserCallback(instance); - } + spiTimeout = 1000; + while (SPI_I2S_GetFlagStatus(instance, SPI_I2S_FLAG_RXNE) == RESET) { + if ((spiTimeout--) == 0) + return spiTimeoutUserCallback(instance); + } #ifdef STM32F303xC - b = SPI_ReceiveData8(instance); - //b = SPI_I2S_ReceiveData16(instance); + b = SPI_ReceiveData8(instance); #else - b = SPI_I2S_ReceiveData(instance); + b = SPI_I2S_ReceiveData(instance); #endif - if (out) - *(out++) = b; - } + if (out) + *(out++) = b; + } - return true; + return true; } - void spiSetDivisor(SPI_TypeDef *instance, uint16_t divisor) { #define BR_CLEAR_MASK 0xFFC7 - uint16_t tempRegister; + uint16_t tempRegister; - SPI_Cmd(instance, DISABLE); + SPI_Cmd(instance, DISABLE); - tempRegister = instance->CR1; + tempRegister = instance->CR1; - switch (divisor) { - case 2: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_2; - break; + switch (divisor) { + case 2: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_2; + break; - case 4: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_4; - break; + case 4: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_4; + break; - case 8: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_8; - break; + case 8: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_8; + break; - case 16: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_16; - break; + case 16: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_16; + break; - case 32: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_32; - break; + case 32: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_32; + break; - case 64: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_64; - break; + case 64: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_64; + break; - case 128: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_128; - break; + case 128: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_128; + break; - case 256: - tempRegister &= BR_CLEAR_MASK; - tempRegister |= SPI_BaudRatePrescaler_256; - break; - } + case 256: + tempRegister &= BR_CLEAR_MASK; + tempRegister |= SPI_BaudRatePrescaler_256; + 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; + 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; + SPIDevice device = spiDeviceByInstance(instance); + if (device != SPIINVALID) + spiHardwareMap[device].errorCount = 0; } \ No newline at end of file diff --git a/src/main/drivers/bus_spi.h b/src/main/drivers/bus_spi.h index 1d5eca6bc..5acf9150e 100644 --- a/src/main/drivers/bus_spi.h +++ b/src/main/drivers/bus_spi.h @@ -17,41 +17,46 @@ #pragma once +/* #define SPI_0_28125MHZ_CLOCK_DIVIDER 256 #define SPI_0_5625MHZ_CLOCK_DIVIDER 128 #define SPI_18MHZ_CLOCK_DIVIDER 2 #define SPI_9MHZ_CLOCK_DIVIDER 4 +*/ #include #include "io.h" #include "rcc.h" -#if defined(STM32F40_41xxx) || defined (STM32F411xE) || defined(STM32F303xC) -#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(STM32F10X) -#define SPI_IO_AF_CFG IO_CONFIG(GPIO_Mode_AF_OD, GPIO_Speed_50MHz) -#define SPI_IO_CS_CFG IO_CONFIG(GPIO_Mode_Out_OD, GPIO_Speed_50MHz) +#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_CFG IO_CONFIG(GPIO_Mode_AF_OD, GPIO_Speed_50MHz) +#define SPI_IO_CS_CFG IO_CONFIG(GPIO_Mode_Out_OD, GPIO_Speed_50MHz) #else #error "Unknown processor" #endif -#if defined(STM32F40_41xxx) || defined (STM32F411xE) - -#define SPI_SLOW_CLOCK 128 //00.65625 MHz -#define SPI_STANDARD_CLOCK 8 //11.50000 MHz -#define SPI_FAST_CLOCK 4 //21.00000 MHz -#define SPI_ULTRAFAST_CLOCK 2 //42.00000 MHz +/* + 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 - -#define SPI_SLOW_CLOCK 128 //00.56250 MHz -#define SPI_STANDARD_CLOCK 4 //09.00000 MHz -#define SPI_FAST_CLOCK 2 //18.00000 MHz -#define SPI_ULTRAFAST_CLOCK 2 //18.00000 MHz - + 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, diff --git a/src/main/drivers/flash_m25p16.c b/src/main/drivers/flash_m25p16.c index 7640ab768..1063debae 100644 --- a/src/main/drivers/flash_m25p16.c +++ b/src/main/drivers/flash_m25p16.c @@ -95,7 +95,7 @@ static void m25p16_writeEnable() 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]; ENABLE_M25P16; @@ -134,7 +134,7 @@ bool m25p16_waitForReady(uint32_t timeoutMillis) */ 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]; uint32_t chipID; @@ -210,7 +210,7 @@ bool m25p16_init() #ifndef M25P16_SPI_SHARED //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(); diff --git a/src/main/drivers/max7456.c b/src/main/drivers/max7456.c index b8a59bcfc..d3efe7e7d 100644 --- a/src/main/drivers/max7456.c +++ b/src/main/drivers/max7456.c @@ -55,11 +55,11 @@ uint8_t max7456_send(uint8_t add, uint8_t data) { } -void max7456_init(uint8_t video_system) { +void max7456_init(uint8_t video_system) +{ uint8_t max_screen_rows; uint8_t srdata = 0; uint16_t x; - char buf[LINE]; #ifdef MAX7456_SPI_CS_PIN max7456CsPin = IOGetByTag(IO_TAG(MAX7456_SPI_CS_PIN)); @@ -68,7 +68,7 @@ void max7456_init(uint8_t video_system) { IOConfigGPIO(max7456CsPin, SPI_IO_CS_CFG); //Minimum spi clock period for max7456 is 100ns (10Mhz) - spiSetDivisor(MAX7456_SPI_INSTANCE, SPI_9MHZ_CLOCK_DIVIDER); + spiSetDivisor(MAX7456_SPI_INSTANCE, SPI_CLOCK_STANDARD); delay(1000); // force soft reset on Max7456 @@ -77,10 +77,10 @@ void max7456_init(uint8_t video_system) { delay(100); srdata = max7456_send(0xA0, 0xFF); - if ((0x01 & srdata) == 0x01){ //PAL + if ((0x01 & srdata) == 0x01) { //PAL video_signal_type = VIDEO_MODE_PAL; } - else if((0x02 & srdata) == 0x02){ //NTSC + else if ((0x02 & srdata) == 0x02) { //NTSC video_signal_type = VIDEO_MODE_NTSC; } diff --git a/src/main/drivers/vtx_rtc6705.c b/src/main/drivers/vtx_rtc6705.c index 423bd94ed..35e78fe0d 100644 --- a/src/main/drivers/vtx_rtc6705.c +++ b/src/main/drivers/vtx_rtc6705.c @@ -133,7 +133,7 @@ static uint32_t reverse32(uint32_t in) bool rtc6705Init(void) { DISABLE_RTC6705; - spiSetDivisor(RTC6705_SPI_INSTANCE, SPI_0_5625MHZ_CLOCK_DIVIDER); + spiSetDivisor(RTC6705_SPI_INSTANCE, SPI_CLOCK_SLOW); return rtc6705IsReady(); }