diff --git a/src/main/drivers/bus_spi.c b/src/main/drivers/bus_spi.c
index 5af40d075..919b68d75 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 
 
@@ -73,168 +73,168 @@
 
 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 },
+    { .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 }
+    { .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,47 +244,45 @@ 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;
 }
 
 
@@ -292,70 +290,70 @@ 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 39074e418..aea3e133e 100644
--- a/src/main/drivers/bus_spi.h
+++ b/src/main/drivers/bus_spi.h
@@ -40,7 +40,7 @@
 
 #if defined(STM32F4)
 #define SPI_SLOW_CLOCK      128 //00.65625 MHz
-#define SPI_STANDARD_CLOCK   16 //05.25000 MHz
+#define SPI_STANDARD_CLOCK    8 //10.50000 MHz
 #define SPI_FAST_CLOCK        4 //21.00000 MHz
 #define SPI_ULTRAFAST_CLOCK   2 //42.00000 MHz
 #else