From 86298534bbd04ed4ecd743de5d2c089f9b377110 Mon Sep 17 00:00:00 2001 From: fpr Date: Wed, 7 Jun 2017 15:49:22 +0200 Subject: [PATCH 1/3] Fixed issue #11: SPI constructors and SS pin usage modified Signed-off-by: fpr --- cores/arduino/stm32/spi_com.c | 3 +++ libraries/SPI/SPI.cpp | 33 ++++++++++++++++++++++----------- libraries/SPI/SPI.h | 2 +- 3 files changed, 26 insertions(+), 12 deletions(-) diff --git a/cores/arduino/stm32/spi_com.c b/cores/arduino/stm32/spi_com.c index c64cc1bdc6..a4166092d7 100644 --- a/cores/arduino/stm32/spi_com.c +++ b/cores/arduino/stm32/spi_com.c @@ -144,9 +144,12 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb) g_pin_sclk = obj->pin_sclk; if (obj->pin_ssel != NC) { g_pin_ssel = obj->pin_ssel; + handle->Init.NSS = SPI_NSS_HARD_OUTPUT; + handle->Init.NSSPMode = SPI_NSS_PULSE_ENABLE; } else { g_pin_ssel = NC; handle->Init.NSS = SPI_NSS_SOFT; + handle->Init.NSSPMode = SPI_NSS_PULSE_DISABLE; } /* Fill default value */ diff --git a/libraries/SPI/SPI.cpp b/libraries/SPI/SPI.cpp index 13257b4a95..0b20e00ec6 100644 --- a/libraries/SPI/SPI.cpp +++ b/libraries/SPI/SPI.cpp @@ -11,7 +11,11 @@ #include "SPI.h" - +/* The following contructors are available: +- SPIClass SPI +- SPIClass SPI(mosi,miso,sclk) +- SPIClass SPI(mosi,miso,sclk,ss) +*/ SPIClass SPI; SPIClass::SPIClass() : g_active_id(-1) @@ -22,13 +26,20 @@ SPIClass::SPIClass() : g_active_id(-1) _spi.pin_ssel = NC; } +/* By default hardware SS pin is not used. To use hardware SS pin you should set +ssel pin. Enable this pin disable software CS. See microcontroller documentation +for the list of available SS pins. */ SPIClass::SPIClass(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t ssel) : g_active_id(-1) { _spi.pin_miso = digitalToPinName(miso); _spi.pin_mosi = digitalToPinName(mosi); _spi.pin_sclk = digitalToPinName(sclk); - // If no ssel pin used, set it to value NUM_DIGITAL_PINS - _spi.pin_ssel = digitalToPinName(ssel); + + if(ssel != 0xFF) { + _spi.pin_ssel = digitalToPinName(ssel); + } else { + _spi.pin_ssel = NC; + } } //begin using the default chip select @@ -43,7 +54,7 @@ void SPIClass::begin(uint8_t _pin) if(_pin > SPI_CHANNELS_NUM) return; - if(_pin != BOARD_SPI_OWN_SS) { + if((_pin != BOARD_SPI_OWN_SS) && (_spi.pin_ssel == NC)) { pinMode(_pin, OUTPUT); digitalWrite(_pin, HIGH); } @@ -185,12 +196,12 @@ byte SPIClass::transfer(uint8_t _pin, uint8_t data, SPITransferMode _mode) g_active_id = _pin; } - if(_pin != BOARD_SPI_OWN_SS) + if((_pin != BOARD_SPI_OWN_SS) && (_spi.pin_ssel == NC)) digitalWrite(_pin, LOW); - spi_transfer(&_spi, &data, &rx_buffer, sizeof(uint8_t), 10000000); + spi_transfer(&_spi, &data, &rx_buffer, sizeof(uint8_t), 10000); - if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST)) + if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST) && (_spi.pin_ssel == NC)) digitalWrite(_pin, HIGH); return rx_buffer; @@ -208,12 +219,12 @@ uint16_t SPIClass::transfer16(uint8_t _pin, uint16_t data, SPITransferMode _mode g_active_id = _pin; } - if(_pin != BOARD_SPI_OWN_SS) + if((_pin != BOARD_SPI_OWN_SS) && (_spi.pin_ssel == NC)) digitalWrite(_pin, LOW); spi_transfer(&_spi, (uint8_t *)&data, (uint8_t *)&rx_buffer, sizeof(uint16_t), 10000000); - if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST)) + if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST) && (_spi.pin_ssel == NC)) digitalWrite(_pin, HIGH); return rx_buffer; @@ -229,12 +240,12 @@ void SPIClass::transfer(uint8_t _pin, void *_buf, size_t _count, SPITransferMode g_active_id = _pin; } - if(_pin != BOARD_SPI_OWN_SS) + if((_pin != BOARD_SPI_OWN_SS) && (_spi.pin_ssel == NC)) digitalWrite(_pin, LOW); spi_send(&_spi,(uint8_t *)_buf, _count,10000); - if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST)) + if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST) && (_spi.pin_ssel == NC)) digitalWrite(_pin, HIGH); } diff --git a/libraries/SPI/SPI.h b/libraries/SPI/SPI.h index c56c9e1567..3e3eba3cef 100644 --- a/libraries/SPI/SPI.h +++ b/libraries/SPI/SPI.h @@ -125,7 +125,7 @@ class SPISettings { class SPIClass { public: SPIClass(); - SPIClass(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t ssel); + SPIClass(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t ssel = 0xFF); // Transfer functions byte transfer(byte _pin, uint8_t _data, SPITransferMode _mode = SPI_LAST); From 8b2ab03243f9193012a8a47f8b1f771071f0e296 Mon Sep 17 00:00:00 2001 From: "Frederic.Pillon" Date: Fri, 9 Jun 2017 15:37:32 +0200 Subject: [PATCH 2/3] Fix SPI clock freq definition Signed-off-by: Frederic.Pillon --- cores/arduino/stm32/spi_com.c | 83 +++++++++++++++++++++++++++++++---- cores/arduino/stm32/spi_com.h | 19 ++++---- libraries/SPI/SPI.cpp | 27 ++++-------- libraries/SPI/SPI.h | 31 ++----------- 4 files changed, 99 insertions(+), 61 deletions(-) diff --git a/cores/arduino/stm32/spi_com.c b/cores/arduino/stm32/spi_com.c index c64cc1bdc6..bb71a1e1a2 100644 --- a/cores/arduino/stm32/spi_com.c +++ b/cores/arduino/stm32/spi_com.c @@ -106,6 +106,71 @@ static PinName g_pin_ssel = NC; /** @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 @@ -120,6 +185,7 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb) return; SPI_HandleTypeDef *handle = &(obj->handle); + uint32_t spi_freq = 0; // Determine the SPI to use uint32_t spi_mosi = pinmap_peripheral(obj->pin_mosi, PinMap_SPI_MOSI); @@ -153,21 +219,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; diff --git a/cores/arduino/stm32/spi_com.h b/cores/arduino/stm32/spi_com.h index bc3143164c..8d9e50d716 100644 --- a/cores/arduino/stm32/spi_com.h +++ b/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 } diff --git a/libraries/SPI/SPI.cpp b/libraries/SPI/SPI.cpp index 13257b4a95..95746351ba 100644 --- a/libraries/SPI/SPI.cpp +++ b/libraries/SPI/SPI.cpp @@ -129,39 +129,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; } diff --git a/libraries/SPI/SPI.h b/libraries/SPI/SPI.h index c56c9e1567..1335bd274e 100644 --- a/libraries/SPI/SPI.h +++ b/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; From ea8aea7462a062e0692d7bac0b3c3853cf504a3c Mon Sep 17 00:00:00 2001 From: fpr Date: Fri, 9 Jun 2017 15:40:50 +0200 Subject: [PATCH 3/3] Global variables removed (more secure). Exit init if pins are NC. Signed-off-by: fpr --- cores/arduino/stm32/spi_com.c | 95 ++++++++++++++--------------------- 1 file changed, 39 insertions(+), 56 deletions(-) diff --git a/cores/arduino/stm32/spi_com.c b/cores/arduino/stm32/spi_com.c index a4166092d7..5c58a205cb 100644 --- a/cores/arduino/stm32/spi_com.c +++ b/cores/arduino/stm32/spi_com.c @@ -86,11 +86,6 @@ * @{ */ -static PinName g_pin_mosi = NC; -static PinName g_pin_miso = NC; -static PinName g_pin_sclk = NC; -static PinName g_pin_ssel = NC; - /** * @} */ @@ -120,6 +115,8 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb) return; SPI_HandleTypeDef *handle = &(obj->handle); + GPIO_InitTypeDef GPIO_InitStruct; + GPIO_TypeDef *port; // Determine the SPI to use uint32_t spi_mosi = pinmap_peripheral(obj->pin_mosi, PinMap_SPI_MOSI); @@ -127,6 +124,11 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb) uint32_t spi_sclk = pinmap_peripheral(obj->pin_sclk, PinMap_SPI_SCLK); uint32_t spi_ssel = pinmap_peripheral(obj->pin_ssel, PinMap_SPI_SSEL); + /* Pins MOSI/MISO/SCLK must not be NC. ssel can be NC. */ + if(spi_mosi == NC || spi_miso == NC || spi_sclk == NC) { + return; + } + uint32_t spi_data = pinmap_merge(spi_mosi, spi_miso); uint32_t spi_cntl = pinmap_merge(spi_sclk, spi_ssel); @@ -139,17 +141,10 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb) } // Configure the SPI pins - g_pin_mosi = obj->pin_mosi; - g_pin_miso = obj->pin_miso; - g_pin_sclk = obj->pin_sclk; if (obj->pin_ssel != NC) { - g_pin_ssel = obj->pin_ssel; handle->Init.NSS = SPI_NSS_HARD_OUTPUT; - handle->Init.NSSPMode = SPI_NSS_PULSE_ENABLE; } else { - g_pin_ssel = NC; handle->Init.NSS = SPI_NSS_SOFT; - handle->Init.NSSPMode = SPI_NSS_PULSE_DISABLE; } /* Fill default value */ @@ -202,96 +197,84 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb) handle->Init.TIMode = SPI_TIMODE_DISABLED; - HAL_SPI_Init(handle); -} - -/** - * @brief Initialize the SPI MSP. - * @param hspi: pointer to a SPI_HandleTypeDef structure that contains - * the configuration information for SPI module. - * @retval None - */ -void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi) -{ - GPIO_InitTypeDef GPIO_InitStruct; - GPIO_TypeDef *port; - - if(g_pin_mosi != NC) { - port = set_GPIO_Port_Clock(STM_PORT(g_pin_mosi)); - GPIO_InitStruct.Pin = STM_GPIO_PIN(g_pin_mosi); - GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(g_pin_mosi,PinMap_SPI_MOSI)); - GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(g_pin_mosi,PinMap_SPI_MOSI)); + if(obj->pin_mosi != NC) { + port = set_GPIO_Port_Clock(STM_PORT(obj->pin_mosi)); + GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_mosi); + GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)); + GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)); GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; - GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(g_pin_mosi,PinMap_SPI_MOSI)); + GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)); HAL_GPIO_Init(port, &GPIO_InitStruct); } - if(g_pin_miso != NC) { - port = set_GPIO_Port_Clock(STM_PORT(g_pin_miso)); - GPIO_InitStruct.Pin = STM_GPIO_PIN(g_pin_miso); - GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(g_pin_miso,PinMap_SPI_MISO)); - GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(g_pin_miso,PinMap_SPI_MISO)); + if(obj->pin_miso != NC) { + port = set_GPIO_Port_Clock(STM_PORT(obj->pin_miso)); + GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_miso); + GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)); + GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)); GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; - GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(g_pin_miso,PinMap_SPI_MISO)); + GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)); HAL_GPIO_Init(port, &GPIO_InitStruct); } - if(g_pin_sclk != NC) { - port = set_GPIO_Port_Clock(STM_PORT(g_pin_sclk)); - GPIO_InitStruct.Pin = STM_GPIO_PIN(g_pin_sclk); - GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(g_pin_sclk,PinMap_SPI_SCLK)); - GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(g_pin_sclk,PinMap_SPI_SCLK)); + if(obj->pin_sclk != NC) { + port = set_GPIO_Port_Clock(STM_PORT(obj->pin_sclk)); + GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_sclk); + GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK)); + GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK)); GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; - GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(g_pin_sclk,PinMap_SPI_SCLK)); + GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK)); HAL_GPIO_Init(port, &GPIO_InitStruct); } - if(g_pin_ssel != NC) { - port = set_GPIO_Port_Clock(STM_PORT(g_pin_ssel)); - GPIO_InitStruct.Pin = STM_GPIO_PIN(g_pin_ssel); - GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(g_pin_ssel,PinMap_SPI_SSEL)); - GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(g_pin_ssel,PinMap_SPI_SSEL)); + if(obj->pin_ssel != NC) { + port = set_GPIO_Port_Clock(STM_PORT(obj->pin_ssel)); + GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_ssel); + GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)); + GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)); GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; - GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(g_pin_ssel,PinMap_SPI_SSEL)); + GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)); HAL_GPIO_Init(port, &GPIO_InitStruct); } #if defined SPI1_BASE // Enable SPI clock - if (hspi->Instance == SPI1) { + if (handle->Instance == SPI1) { __HAL_RCC_SPI1_CLK_ENABLE(); } #endif #if defined SPI2_BASE - if (hspi->Instance == SPI2) { + if (handle->Instance == SPI2) { __HAL_RCC_SPI2_CLK_ENABLE(); } #endif #if defined SPI3_BASE - if (hspi->Instance == SPI3) { + if (handle->Instance == SPI3) { __HAL_RCC_SPI3_CLK_ENABLE(); } #endif #if defined SPI4_BASE - if (hspi->Instance == SPI4) { + if (handle->Instance == SPI4) { __HAL_RCC_SPI4_CLK_ENABLE(); } #endif #if defined SPI5_BASE - if (hspi->Instance == SPI5) { + if (handle->Instance == SPI5) { __HAL_RCC_SPI5_CLK_ENABLE(); } #endif #if defined SPI6_BASE - if (hspi->Instance == SPI6) { + if (handle->Instance == SPI6) { __HAL_RCC_SPI6_CLK_ENABLE(); } #endif + + HAL_SPI_Init(handle); } /**