Merge branch 'SPI_Freq' into issue_11

Author: fpr

cores/arduino/stm32/spi_com.c

@@ -101,6 +101,71 @@
 /** @addtogroup STM32F4xx_System_Private_Functions
   * @{
   */
+/**
+  * @brief  return clock freq of an SPI instance
+  * @param  spi_inst : SPI instance
+  * @retval clock freq of the instance else SystemCoreClock
+  */
+uint32_t spi_getClkFreqInst(SPI_TypeDef * spi_inst)
+{
+  uint32_t spi_freq = SystemCoreClock;
+
+#ifdef STM32F0xx
+  /* SPIx source CLK is PCKL1 */
+  spi_freq = HAL_RCC_GetPCLK1Freq();
+#else
+  if(spi_inst != (SPI_TypeDef *)NC) {
+    /* Get source clock depending on SPI instance */
+    switch ((uint32_t)spi_inst) {
+      case (uint32_t)SPI1:
+#if defined SPI4_BASE
+      case (uint32_t)SPI4:
+#endif
+#if defined SPI5_BASE
+      case (uint32_t)SPI5:
+#endif
+#if defined SPI6_BASE
+      case (uint32_t)SPI6:
+#endif
+        /* SPI1, SPI4, SPI5 and SPI6. Source CLK is PCKL2 */
+        spi_freq = HAL_RCC_GetPCLK2Freq();
+        break;
+      case (uint32_t)SPI2:
+#if defined SPI3_BASE
+      case (uint32_t)SPI3:
+#endif
+        /* SPI_2 and SPI_3. Source CLK is PCKL1 */
+        spi_freq = HAL_RCC_GetPCLK1Freq();
+        break;
+      default:
+        printf("CLK: SPI instance not set");
+        break;
+    }
+  }
+#endif
+  return spi_freq;
+}
+
+/**
+  * @brief  return clock freq of an SPI instance
+  * @param  obj : pointer to spi_t structure
+  * @retval clock freq of the instance else SystemCoreClock
+  */
+uint32_t spi_getClkFreq(spi_t *obj)
+{
+  uint32_t spi_inst = NC;
+  uint32_t spi_freq = SystemCoreClock;
+
+  if(obj != NULL) {
+	spi_inst = pinmap_peripheral(obj->pin_sclk, PinMap_SPI_SCLK);
+
+    if(spi_inst != NC) {
+      spi_freq = spi_getClkFreqInst(spi_inst);
+	}
+  }
+  return spi_freq;
+}
+
 /**
   * @brief  SPI initialization function
   * @param  obj : pointer to spi_t structure
@@ -117,6 +182,7 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb)
   SPI_HandleTypeDef *handle = &(obj->handle);
   GPIO_InitTypeDef  GPIO_InitStruct;
   GPIO_TypeDef *port;
+  uint32_t spi_freq = 0;
 
   // Determine the SPI to use
   uint32_t spi_mosi = pinmap_peripheral(obj->pin_mosi, PinMap_SPI_MOSI);
@@ -151,21 +217,22 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb)
   handle->Instance               = obj->spi;
   handle->Init.Mode              = SPI_MODE_MASTER;
 
-  if(speed >= SPI_SPEED_CLOCK_DIV2_MHZ) {
+  spi_freq = spi_getClkFreqInst(obj->spi);
+  if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV2_MHZ)) {
     handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
-  } else if(speed >= SPI_SPEED_CLOCK_DIV4_MHZ) {
+  } else if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV4_MHZ)) {
     handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
-  } else if (speed >= SPI_SPEED_CLOCK_DIV8_MHZ) {
+  } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV8_MHZ)) {
     handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
-  } else if (speed >= SPI_SPEED_CLOCK_DIV16_MHZ) {
+  } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV16_MHZ)) {
     handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
-  } else if (speed >= SPI_SPEED_CLOCK_DIV32_MHZ) {
+  } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV32_MHZ)) {
     handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
-  } else if (speed >= SPI_SPEED_CLOCK_DIV64_MHZ) {
+  } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV64_MHZ)) {
     handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
-  } else if (speed >= SPI_SPEED_CLOCK_DIV128_MHZ) {
+  } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV128_MHZ)) {
     handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
-  } else if (speed >= SPI_SPEED_CLOCK_DIV256_MHZ) {
+  } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV256_MHZ)) {
     handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
   } else {
     handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;

cores/arduino/stm32/spi_com.h

@@ -62,14 +62,16 @@ typedef struct spi_s spi_t;
 
 
 ///@brief specifies the SPI speed bus in HZ.
-#define SPI_SPEED_CLOCK_DIV2_MHZ    ((uint32_t)(SystemCoreClock/2))
-#define SPI_SPEED_CLOCK_DIV4_MHZ    ((uint32_t)(SystemCoreClock/4))
-#define SPI_SPEED_CLOCK_DIV8_MHZ    ((uint32_t)(SystemCoreClock/8))
-#define SPI_SPEED_CLOCK_DIV16_MHZ   ((uint32_t)(SystemCoreClock/16))
-#define SPI_SPEED_CLOCK_DIV32_MHZ   ((uint32_t)(SystemCoreClock/32))
-#define SPI_SPEED_CLOCK_DIV64_MHZ   ((uint32_t)(SystemCoreClock/64))
-#define SPI_SPEED_CLOCK_DIV128_MHZ  ((uint32_t)(SystemCoreClock/128))
-#define SPI_SPEED_CLOCK_DIV256_MHZ  ((uint32_t)(SystemCoreClock/256))
+#define SPI_SPEED_CLOCK_DEFAULT     4000000
+
+#define SPI_SPEED_CLOCK_DIV2_MHZ    ((uint32_t)2)
+#define SPI_SPEED_CLOCK_DIV4_MHZ    ((uint32_t)4)
+#define SPI_SPEED_CLOCK_DIV8_MHZ    ((uint32_t)8)
+#define SPI_SPEED_CLOCK_DIV16_MHZ   ((uint32_t)16)
+#define SPI_SPEED_CLOCK_DIV32_MHZ   ((uint32_t)32)
+#define SPI_SPEED_CLOCK_DIV64_MHZ   ((uint32_t)64)
+#define SPI_SPEED_CLOCK_DIV128_MHZ  ((uint32_t)128)
+#define SPI_SPEED_CLOCK_DIV256_MHZ  ((uint32_t)256)
 
 ///@brief speficies the SPI mode to use
 //Mode          Clock Polarity (CPOL)       Clock Phase (CPHA)
@@ -101,6 +103,7 @@ void spi_deinit(spi_t *obj);
 spi_status_e spi_send(spi_t *obj, uint8_t *Data, uint16_t len, uint32_t Timeout);
 spi_status_e spi_transfer(spi_t *obj, uint8_t * tx_buffer,
                       uint8_t * rx_buffer, uint16_t len, uint32_t Timeout);
+uint32_t spi_getClkFreq(spi_t *obj);
 
 #ifdef __cplusplus
 }

cores/arduino/stm32/uart.c

@@ -89,7 +89,7 @@
   */
 /// @brief uart caracteristics
 #define UART_NUM (8)
-static UART_HandleTypeDef *uart_handlers[UART_NUM];
+static UART_HandleTypeDef *uart_handlers[UART_NUM] = {NULL};
 static void (*rx_callback[UART_NUM])(serial_t*);
 static serial_t *rx_callback_obj[UART_NUM];
 static int (*tx_callback[UART_NUM])(serial_t*);
@@ -336,21 +336,27 @@ size_t uart_write(serial_t *obj, uint8_t data, uint16_t size)
 size_t uart_debug_write(uint8_t *data, uint32_t size)
 {
   uint8_t index = 0;
+  uint32_t tickstart = HAL_GetTick();
+
   for(index = 0; index < UART_NUM; index++) {
-    if(DEBUG_UART == uart_handlers[index]->Instance) {
-      break;
+    if(uart_handlers[index] != NULL) {
+      if(DEBUG_UART == uart_handlers[index]->Instance) {
+        break;
+      }
     }
   }
 
   if(index >= UART_NUM) {
     return 0;
   }
 
-  if(HAL_UART_Transmit(uart_handlers[index], data, size, TX_TIMEOUT) == HAL_OK) {
-    return 1;
-  } else {
-    return 0;
+  while(HAL_UART_Transmit(uart_handlers[index], data, size, TX_TIMEOUT) != HAL_OK) {
+    if((HAL_GetTick() - tickstart) >=  TX_TIMEOUT) {
+      return 0;
+    }
   }
+
+  return size;
 }
 
 /**

libraries/SPI/SPI.cpp

@@ -140,39 +140,30 @@ void SPIClass::setDataMode(uint8_t _pin, uint8_t _mode)
   g_active_id = _pin;
 }
 
+/*
+ * This function should not be used in new projects.
+ * Use SPISettings with SPI.beginTransaction() to configure SPI parameters.
+ */
 void SPIClass::setClockDivider(uint8_t _pin, uint8_t _divider)
 {
   if(_pin > SPI_CHANNELS_NUM)
     return;
 
+  /* Get clk freq of the SPI instance */
+  uint32_t spiClkFreq = spi_getClkFreq(&_spi);
+
   switch(_divider) {
     case (SPI_CLOCK_DIV2) :
-      spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV2_MHZ;
-    break;
     case (SPI_CLOCK_DIV4) :
-      spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV4_MHZ;
-    break;
     case (SPI_CLOCK_DIV8) :
-      spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV8_MHZ;
-    break;
     case (SPI_CLOCK_DIV16) :
-      spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV16_MHZ;
-    break;
     case (SPI_CLOCK_DIV32) :
-      spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV32_MHZ;
-    break;
     case (SPI_CLOCK_DIV64) :
-      spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV64_MHZ;
-    break;
     case (SPI_CLOCK_DIV128) :
-      spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV128_MHZ;
+      spiSettings[_pin].clk = spiClkFreq/_divider;
     break;
     default:
-#if defined (STM32F0xx) || defined (STM32F3xx) || defined (STM32L0xx)
-      spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV64_MHZ;
-#else
-      spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV16_MHZ;
-#endif
+      spiSettings[_pin].clk = SPI_SPEED_CLOCK_DEFAULT;
     break;
   }
 

libraries/SPI/SPI.h

@@ -35,7 +35,8 @@
 
 // For compatibility with sketches designed for AVR @ 16 MHz
 // need to go from 64MHz to 16 (/4)
-// New programs should use SPI.beginTransaction to set the SPI clock
+// This function should not be used in new projects.
+// Use SPISettings with SPI.beginTransaction() to configure SPI parameters.
 #define SPI_CLOCK_DIV2	 2
 #define SPI_CLOCK_DIV4	 4
 #define SPI_CLOCK_DIV8	 8
@@ -57,27 +58,7 @@ enum SPITransferMode {
 class SPISettings {
   public:
     SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) {
-      if(clock >= SPI_SPEED_CLOCK_DIV2_MHZ) {
-        clk = SPI_SPEED_CLOCK_DIV2_MHZ;
-      } else if (clock >= SPI_SPEED_CLOCK_DIV4_MHZ) {
-        clk = SPI_SPEED_CLOCK_DIV4_MHZ;
-      } else if (clock >= SPI_SPEED_CLOCK_DIV8_MHZ) {
-        clk = SPI_SPEED_CLOCK_DIV8_MHZ;
-      } else if (clock >= SPI_SPEED_CLOCK_DIV16_MHZ) {
-        clk = SPI_SPEED_CLOCK_DIV16_MHZ;
-      } else if (clock >= SPI_SPEED_CLOCK_DIV32_MHZ) {
-        clk = SPI_SPEED_CLOCK_DIV32_MHZ;
-      } else if (clock >= SPI_SPEED_CLOCK_DIV64_MHZ) {
-        clk = SPI_SPEED_CLOCK_DIV64_MHZ;
-      } else if (clock >= SPI_SPEED_CLOCK_DIV128_MHZ) {
-        clk = SPI_SPEED_CLOCK_DIV128_MHZ;
-      } else {
-#if defined (STM32F0xx) || defined(STM32F3xx) || defined(STM32L0xx)
-        clk = SPI_SPEED_CLOCK_DIV256_MHZ;
-#else
-        clk = SPI_SPEED_CLOCK_DIV16_MHZ;
-#endif
-      }
+      clk = clock;
 
       if(bitOrder == MSBFIRST) {
         msb = 1;
@@ -98,11 +79,7 @@ class SPISettings {
 
     }
     SPISettings() {
-#if defined (STM32F0xx) || defined(STM32F3xx)
-      clk = SPI_SPEED_CLOCK_DIV64_MHZ;
-#else
-      clk = SPI_SPEED_CLOCK_DIV16_MHZ;
-#endif
+      clk = SPI_SPEED_CLOCK_DEFAULT;
       bOrder = MSBFIRST;
       msb = 1;
       dMode = SPI_MODE_0;