Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 055864f

Browse files
fpistmfpistm
authoredJun 9, 2017
Merge pull request #15 from stm32duino/issue_11
Fixed issue #11: SPI constructors and SS pin usage modified
2 parents dadfba3 + 052443e commit 055864f

File tree

4 files changed

+162
-127
lines changed

4 files changed

+162
-127
lines changed
 

‎cores/arduino/stm32/spi_com.c

Lines changed: 115 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -86,11 +86,6 @@
8686
* @{
8787
*/
8888

89-
static PinName g_pin_mosi = NC;
90-
static PinName g_pin_miso = NC;
91-
static PinName g_pin_sclk = NC;
92-
static PinName g_pin_ssel = NC;
93-
9489
/**
9590
* @}
9691
*/
@@ -106,6 +101,71 @@ static PinName g_pin_ssel = NC;
106101
/** @addtogroup STM32F4xx_System_Private_Functions
107102
* @{
108103
*/
104+
/**
105+
* @brief return clock freq of an SPI instance
106+
* @param spi_inst : SPI instance
107+
* @retval clock freq of the instance else SystemCoreClock
108+
*/
109+
uint32_t spi_getClkFreqInst(SPI_TypeDef * spi_inst)
110+
{
111+
uint32_t spi_freq = SystemCoreClock;
112+
113+
#ifdef STM32F0xx
114+
/* SPIx source CLK is PCKL1 */
115+
spi_freq = HAL_RCC_GetPCLK1Freq();
116+
#else
117+
if(spi_inst != (SPI_TypeDef *)NC) {
118+
/* Get source clock depending on SPI instance */
119+
switch ((uint32_t)spi_inst) {
120+
case (uint32_t)SPI1:
121+
#if defined SPI4_BASE
122+
case (uint32_t)SPI4:
123+
#endif
124+
#if defined SPI5_BASE
125+
case (uint32_t)SPI5:
126+
#endif
127+
#if defined SPI6_BASE
128+
case (uint32_t)SPI6:
129+
#endif
130+
/* SPI1, SPI4, SPI5 and SPI6. Source CLK is PCKL2 */
131+
spi_freq = HAL_RCC_GetPCLK2Freq();
132+
break;
133+
case (uint32_t)SPI2:
134+
#if defined SPI3_BASE
135+
case (uint32_t)SPI3:
136+
#endif
137+
/* SPI_2 and SPI_3. Source CLK is PCKL1 */
138+
spi_freq = HAL_RCC_GetPCLK1Freq();
139+
break;
140+
default:
141+
printf("CLK: SPI instance not set");
142+
break;
143+
}
144+
}
145+
#endif
146+
return spi_freq;
147+
}
148+
149+
/**
150+
* @brief return clock freq of an SPI instance
151+
* @param obj : pointer to spi_t structure
152+
* @retval clock freq of the instance else SystemCoreClock
153+
*/
154+
uint32_t spi_getClkFreq(spi_t *obj)
155+
{
156+
uint32_t spi_inst = NC;
157+
uint32_t spi_freq = SystemCoreClock;
158+
159+
if(obj != NULL) {
160+
spi_inst = pinmap_peripheral(obj->pin_sclk, PinMap_SPI_SCLK);
161+
162+
if(spi_inst != NC) {
163+
spi_freq = spi_getClkFreqInst(spi_inst);
164+
}
165+
}
166+
return spi_freq;
167+
}
168+
109169
/**
110170
* @brief SPI initialization function
111171
* @param obj : pointer to spi_t structure
@@ -120,13 +180,21 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb)
120180
return;
121181

122182
SPI_HandleTypeDef *handle = &(obj->handle);
183+
GPIO_InitTypeDef GPIO_InitStruct;
184+
GPIO_TypeDef *port;
185+
uint32_t spi_freq = 0;
123186

124187
// Determine the SPI to use
125188
uint32_t spi_mosi = pinmap_peripheral(obj->pin_mosi, PinMap_SPI_MOSI);
126189
uint32_t spi_miso = pinmap_peripheral(obj->pin_miso, PinMap_SPI_MISO);
127190
uint32_t spi_sclk = pinmap_peripheral(obj->pin_sclk, PinMap_SPI_SCLK);
128191
uint32_t spi_ssel = pinmap_peripheral(obj->pin_ssel, PinMap_SPI_SSEL);
129192

193+
/* Pins MOSI/MISO/SCLK must not be NC. ssel can be NC. */
194+
if(spi_mosi == NC || spi_miso == NC || spi_sclk == NC) {
195+
return;
196+
}
197+
130198
uint32_t spi_data = pinmap_merge(spi_mosi, spi_miso);
131199
uint32_t spi_cntl = pinmap_merge(spi_sclk, spi_ssel);
132200

@@ -139,35 +207,32 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb)
139207
}
140208

141209
// Configure the SPI pins
142-
g_pin_mosi = obj->pin_mosi;
143-
g_pin_miso = obj->pin_miso;
144-
g_pin_sclk = obj->pin_sclk;
145210
if (obj->pin_ssel != NC) {
146-
g_pin_ssel = obj->pin_ssel;
211+
handle->Init.NSS = SPI_NSS_HARD_OUTPUT;
147212
} else {
148-
g_pin_ssel = NC;
149213
handle->Init.NSS = SPI_NSS_SOFT;
150214
}
151215

152216
/* Fill default value */
153217
handle->Instance = obj->spi;
154218
handle->Init.Mode = SPI_MODE_MASTER;
155219

156-
if(speed >= SPI_SPEED_CLOCK_DIV2_MHZ) {
220+
spi_freq = spi_getClkFreqInst(obj->spi);
221+
if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV2_MHZ)) {
157222
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
158-
} else if(speed >= SPI_SPEED_CLOCK_DIV4_MHZ) {
223+
} else if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV4_MHZ)) {
159224
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
160-
} else if (speed >= SPI_SPEED_CLOCK_DIV8_MHZ) {
225+
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV8_MHZ)) {
161226
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
162-
} else if (speed >= SPI_SPEED_CLOCK_DIV16_MHZ) {
227+
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV16_MHZ)) {
163228
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
164-
} else if (speed >= SPI_SPEED_CLOCK_DIV32_MHZ) {
229+
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV32_MHZ)) {
165230
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
166-
} else if (speed >= SPI_SPEED_CLOCK_DIV64_MHZ) {
231+
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV64_MHZ)) {
167232
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
168-
} else if (speed >= SPI_SPEED_CLOCK_DIV128_MHZ) {
233+
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV128_MHZ)) {
169234
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
170-
} else if (speed >= SPI_SPEED_CLOCK_DIV256_MHZ) {
235+
} else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV256_MHZ)) {
171236
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
172237
} else {
173238
handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
@@ -199,96 +264,84 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb)
199264

200265
handle->Init.TIMode = SPI_TIMODE_DISABLED;
201266

202-
HAL_SPI_Init(handle);
203-
}
204-
205-
/**
206-
* @brief Initialize the SPI MSP.
207-
* @param hspi: pointer to a SPI_HandleTypeDef structure that contains
208-
* the configuration information for SPI module.
209-
* @retval None
210-
*/
211-
void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
212-
{
213-
GPIO_InitTypeDef GPIO_InitStruct;
214-
GPIO_TypeDef *port;
215-
216-
if(g_pin_mosi != NC) {
217-
port = set_GPIO_Port_Clock(STM_PORT(g_pin_mosi));
218-
GPIO_InitStruct.Pin = STM_GPIO_PIN(g_pin_mosi);
219-
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(g_pin_mosi,PinMap_SPI_MOSI));
220-
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(g_pin_mosi,PinMap_SPI_MOSI));
267+
if(obj->pin_mosi != NC) {
268+
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_mosi));
269+
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_mosi);
270+
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI));
271+
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI));
221272
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
222-
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(g_pin_mosi,PinMap_SPI_MOSI));
273+
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI));
223274
HAL_GPIO_Init(port, &GPIO_InitStruct);
224275
}
225276

226-
if(g_pin_miso != NC) {
227-
port = set_GPIO_Port_Clock(STM_PORT(g_pin_miso));
228-
GPIO_InitStruct.Pin = STM_GPIO_PIN(g_pin_miso);
229-
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(g_pin_miso,PinMap_SPI_MISO));
230-
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(g_pin_miso,PinMap_SPI_MISO));
277+
if(obj->pin_miso != NC) {
278+
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_miso));
279+
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_miso);
280+
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_miso,PinMap_SPI_MISO));
281+
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_miso,PinMap_SPI_MISO));
231282
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
232-
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(g_pin_miso,PinMap_SPI_MISO));
283+
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_miso,PinMap_SPI_MISO));
233284
HAL_GPIO_Init(port, &GPIO_InitStruct);
234285
}
235286

236-
if(g_pin_sclk != NC) {
237-
port = set_GPIO_Port_Clock(STM_PORT(g_pin_sclk));
238-
GPIO_InitStruct.Pin = STM_GPIO_PIN(g_pin_sclk);
239-
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(g_pin_sclk,PinMap_SPI_SCLK));
240-
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(g_pin_sclk,PinMap_SPI_SCLK));
287+
if(obj->pin_sclk != NC) {
288+
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_sclk));
289+
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_sclk);
290+
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK));
291+
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK));
241292
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
242-
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(g_pin_sclk,PinMap_SPI_SCLK));
293+
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK));
243294
HAL_GPIO_Init(port, &GPIO_InitStruct);
244295
}
245296

246-
if(g_pin_ssel != NC) {
247-
port = set_GPIO_Port_Clock(STM_PORT(g_pin_ssel));
248-
GPIO_InitStruct.Pin = STM_GPIO_PIN(g_pin_ssel);
249-
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(g_pin_ssel,PinMap_SPI_SSEL));
250-
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(g_pin_ssel,PinMap_SPI_SSEL));
297+
if(obj->pin_ssel != NC) {
298+
port = set_GPIO_Port_Clock(STM_PORT(obj->pin_ssel));
299+
GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_ssel);
300+
GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL));
301+
GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL));
251302
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
252-
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(g_pin_ssel,PinMap_SPI_SSEL));
303+
GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL));
253304
HAL_GPIO_Init(port, &GPIO_InitStruct);
254305
}
255306

256307
#if defined SPI1_BASE
257308
// Enable SPI clock
258-
if (hspi->Instance == SPI1) {
309+
if (handle->Instance == SPI1) {
259310
__HAL_RCC_SPI1_CLK_ENABLE();
260311
}
261312
#endif
262313

263314
#if defined SPI2_BASE
264-
if (hspi->Instance == SPI2) {
315+
if (handle->Instance == SPI2) {
265316
__HAL_RCC_SPI2_CLK_ENABLE();
266317
}
267318
#endif
268319

269320
#if defined SPI3_BASE
270-
if (hspi->Instance == SPI3) {
321+
if (handle->Instance == SPI3) {
271322
__HAL_RCC_SPI3_CLK_ENABLE();
272323
}
273324
#endif
274325

275326
#if defined SPI4_BASE
276-
if (hspi->Instance == SPI4) {
327+
if (handle->Instance == SPI4) {
277328
__HAL_RCC_SPI4_CLK_ENABLE();
278329
}
279330
#endif
280331

281332
#if defined SPI5_BASE
282-
if (hspi->Instance == SPI5) {
333+
if (handle->Instance == SPI5) {
283334
__HAL_RCC_SPI5_CLK_ENABLE();
284335
}
285336
#endif
286337

287338
#if defined SPI6_BASE
288-
if (hspi->Instance == SPI6) {
339+
if (handle->Instance == SPI6) {
289340
__HAL_RCC_SPI6_CLK_ENABLE();
290341
}
291342
#endif
343+
344+
HAL_SPI_Init(handle);
292345
}
293346

294347
/**

‎cores/arduino/stm32/spi_com.h

Lines changed: 11 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -62,14 +62,16 @@ typedef struct spi_s spi_t;
6262

6363

6464
///@brief specifies the SPI speed bus in HZ.
65-
#define SPI_SPEED_CLOCK_DIV2_MHZ ((uint32_t)(SystemCoreClock/2))
66-
#define SPI_SPEED_CLOCK_DIV4_MHZ ((uint32_t)(SystemCoreClock/4))
67-
#define SPI_SPEED_CLOCK_DIV8_MHZ ((uint32_t)(SystemCoreClock/8))
68-
#define SPI_SPEED_CLOCK_DIV16_MHZ ((uint32_t)(SystemCoreClock/16))
69-
#define SPI_SPEED_CLOCK_DIV32_MHZ ((uint32_t)(SystemCoreClock/32))
70-
#define SPI_SPEED_CLOCK_DIV64_MHZ ((uint32_t)(SystemCoreClock/64))
71-
#define SPI_SPEED_CLOCK_DIV128_MHZ ((uint32_t)(SystemCoreClock/128))
72-
#define SPI_SPEED_CLOCK_DIV256_MHZ ((uint32_t)(SystemCoreClock/256))
65+
#define SPI_SPEED_CLOCK_DEFAULT 4000000
66+
67+
#define SPI_SPEED_CLOCK_DIV2_MHZ ((uint32_t)2)
68+
#define SPI_SPEED_CLOCK_DIV4_MHZ ((uint32_t)4)
69+
#define SPI_SPEED_CLOCK_DIV8_MHZ ((uint32_t)8)
70+
#define SPI_SPEED_CLOCK_DIV16_MHZ ((uint32_t)16)
71+
#define SPI_SPEED_CLOCK_DIV32_MHZ ((uint32_t)32)
72+
#define SPI_SPEED_CLOCK_DIV64_MHZ ((uint32_t)64)
73+
#define SPI_SPEED_CLOCK_DIV128_MHZ ((uint32_t)128)
74+
#define SPI_SPEED_CLOCK_DIV256_MHZ ((uint32_t)256)
7375

7476
///@brief speficies the SPI mode to use
7577
//Mode Clock Polarity (CPOL) Clock Phase (CPHA)
@@ -101,6 +103,7 @@ void spi_deinit(spi_t *obj);
101103
spi_status_e spi_send(spi_t *obj, uint8_t *Data, uint16_t len, uint32_t Timeout);
102104
spi_status_e spi_transfer(spi_t *obj, uint8_t * tx_buffer,
103105
uint8_t * rx_buffer, uint16_t len, uint32_t Timeout);
106+
uint32_t spi_getClkFreq(spi_t *obj);
104107

105108
#ifdef __cplusplus
106109
}

‎libraries/SPI/SPI.cpp

Lines changed: 31 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,11 @@
1111

1212
#include "SPI.h"
1313

14-
14+
/* The following contructors are available:
15+
- SPIClass SPI
16+
- SPIClass SPI(mosi,miso,sclk)
17+
- SPIClass SPI(mosi,miso,sclk,ss)
18+
*/
1519
SPIClass SPI;
1620

1721
SPIClass::SPIClass() : g_active_id(-1)
@@ -22,13 +26,20 @@ SPIClass::SPIClass() : g_active_id(-1)
2226
_spi.pin_ssel = NC;
2327
}
2428

29+
/* By default hardware SS pin is not used. To use hardware SS pin you should set
30+
ssel pin. Enable this pin disable software CS. See microcontroller documentation
31+
for the list of available SS pins. */
2532
SPIClass::SPIClass(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t ssel) : g_active_id(-1)
2633
{
2734
_spi.pin_miso = digitalToPinName(miso);
2835
_spi.pin_mosi = digitalToPinName(mosi);
2936
_spi.pin_sclk = digitalToPinName(sclk);
30-
// If no ssel pin used, set it to value NUM_DIGITAL_PINS
31-
_spi.pin_ssel = digitalToPinName(ssel);
37+
38+
if(ssel != 0xFF) {
39+
_spi.pin_ssel = digitalToPinName(ssel);
40+
} else {
41+
_spi.pin_ssel = NC;
42+
}
3243
}
3344

3445
//begin using the default chip select
@@ -43,7 +54,7 @@ void SPIClass::begin(uint8_t _pin)
4354
if(_pin > SPI_CHANNELS_NUM)
4455
return;
4556

46-
if(_pin != BOARD_SPI_OWN_SS) {
57+
if((_pin != BOARD_SPI_OWN_SS) && (_spi.pin_ssel == NC)) {
4758
pinMode(_pin, OUTPUT);
4859
digitalWrite(_pin, HIGH);
4960
}
@@ -129,39 +140,30 @@ void SPIClass::setDataMode(uint8_t _pin, uint8_t _mode)
129140
g_active_id = _pin;
130141
}
131142

143+
/*
144+
* This function should not be used in new projects.
145+
* Use SPISettings with SPI.beginTransaction() to configure SPI parameters.
146+
*/
132147
void SPIClass::setClockDivider(uint8_t _pin, uint8_t _divider)
133148
{
134149
if(_pin > SPI_CHANNELS_NUM)
135150
return;
136151

152+
/* Get clk freq of the SPI instance */
153+
uint32_t spiClkFreq = spi_getClkFreq(&_spi);
154+
137155
switch(_divider) {
138156
case (SPI_CLOCK_DIV2) :
139-
spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV2_MHZ;
140-
break;
141157
case (SPI_CLOCK_DIV4) :
142-
spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV4_MHZ;
143-
break;
144158
case (SPI_CLOCK_DIV8) :
145-
spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV8_MHZ;
146-
break;
147159
case (SPI_CLOCK_DIV16) :
148-
spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV16_MHZ;
149-
break;
150160
case (SPI_CLOCK_DIV32) :
151-
spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV32_MHZ;
152-
break;
153161
case (SPI_CLOCK_DIV64) :
154-
spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV64_MHZ;
155-
break;
156162
case (SPI_CLOCK_DIV128) :
157-
spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV128_MHZ;
163+
spiSettings[_pin].clk = spiClkFreq/_divider;
158164
break;
159165
default:
160-
#if defined (STM32F0xx) || defined (STM32F3xx) || defined (STM32L0xx)
161-
spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV64_MHZ;
162-
#else
163-
spiSettings[_pin].clk = SPI_SPEED_CLOCK_DIV16_MHZ;
164-
#endif
166+
spiSettings[_pin].clk = SPI_SPEED_CLOCK_DEFAULT;
165167
break;
166168
}
167169

@@ -185,12 +187,12 @@ byte SPIClass::transfer(uint8_t _pin, uint8_t data, SPITransferMode _mode)
185187
g_active_id = _pin;
186188
}
187189

188-
if(_pin != BOARD_SPI_OWN_SS)
190+
if((_pin != BOARD_SPI_OWN_SS) && (_spi.pin_ssel == NC))
189191
digitalWrite(_pin, LOW);
190192

191-
spi_transfer(&_spi, &data, &rx_buffer, sizeof(uint8_t), 10000000);
193+
spi_transfer(&_spi, &data, &rx_buffer, sizeof(uint8_t), 10000);
192194

193-
if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST))
195+
if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST) && (_spi.pin_ssel == NC))
194196
digitalWrite(_pin, HIGH);
195197

196198
return rx_buffer;
@@ -208,12 +210,12 @@ uint16_t SPIClass::transfer16(uint8_t _pin, uint16_t data, SPITransferMode _mode
208210
g_active_id = _pin;
209211
}
210212

211-
if(_pin != BOARD_SPI_OWN_SS)
213+
if((_pin != BOARD_SPI_OWN_SS) && (_spi.pin_ssel == NC))
212214
digitalWrite(_pin, LOW);
213215

214216
spi_transfer(&_spi, (uint8_t *)&data, (uint8_t *)&rx_buffer, sizeof(uint16_t), 10000000);
215217

216-
if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST))
218+
if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST) && (_spi.pin_ssel == NC))
217219
digitalWrite(_pin, HIGH);
218220

219221
return rx_buffer;
@@ -229,12 +231,12 @@ void SPIClass::transfer(uint8_t _pin, void *_buf, size_t _count, SPITransferMode
229231
g_active_id = _pin;
230232
}
231233

232-
if(_pin != BOARD_SPI_OWN_SS)
234+
if((_pin != BOARD_SPI_OWN_SS) && (_spi.pin_ssel == NC))
233235
digitalWrite(_pin, LOW);
234236

235237
spi_send(&_spi,(uint8_t *)_buf, _count,10000);
236238

237-
if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST))
239+
if((_pin != BOARD_SPI_OWN_SS) && (_mode == SPI_LAST) && (_spi.pin_ssel == NC))
238240
digitalWrite(_pin, HIGH);
239241
}
240242

‎libraries/SPI/SPI.h

Lines changed: 5 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,8 @@
3535

3636
// For compatibility with sketches designed for AVR @ 16 MHz
3737
// need to go from 64MHz to 16 (/4)
38-
// New programs should use SPI.beginTransaction to set the SPI clock
38+
// This function should not be used in new projects.
39+
// Use SPISettings with SPI.beginTransaction() to configure SPI parameters.
3940
#define SPI_CLOCK_DIV2 2
4041
#define SPI_CLOCK_DIV4 4
4142
#define SPI_CLOCK_DIV8 8
@@ -57,27 +58,7 @@ enum SPITransferMode {
5758
class SPISettings {
5859
public:
5960
SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode) {
60-
if(clock >= SPI_SPEED_CLOCK_DIV2_MHZ) {
61-
clk = SPI_SPEED_CLOCK_DIV2_MHZ;
62-
} else if (clock >= SPI_SPEED_CLOCK_DIV4_MHZ) {
63-
clk = SPI_SPEED_CLOCK_DIV4_MHZ;
64-
} else if (clock >= SPI_SPEED_CLOCK_DIV8_MHZ) {
65-
clk = SPI_SPEED_CLOCK_DIV8_MHZ;
66-
} else if (clock >= SPI_SPEED_CLOCK_DIV16_MHZ) {
67-
clk = SPI_SPEED_CLOCK_DIV16_MHZ;
68-
} else if (clock >= SPI_SPEED_CLOCK_DIV32_MHZ) {
69-
clk = SPI_SPEED_CLOCK_DIV32_MHZ;
70-
} else if (clock >= SPI_SPEED_CLOCK_DIV64_MHZ) {
71-
clk = SPI_SPEED_CLOCK_DIV64_MHZ;
72-
} else if (clock >= SPI_SPEED_CLOCK_DIV128_MHZ) {
73-
clk = SPI_SPEED_CLOCK_DIV128_MHZ;
74-
} else {
75-
#if defined (STM32F0xx) || defined(STM32F3xx) || defined(STM32L0xx)
76-
clk = SPI_SPEED_CLOCK_DIV256_MHZ;
77-
#else
78-
clk = SPI_SPEED_CLOCK_DIV16_MHZ;
79-
#endif
80-
}
61+
clk = clock;
8162

8263
if(bitOrder == MSBFIRST) {
8364
msb = 1;
@@ -98,11 +79,7 @@ class SPISettings {
9879

9980
}
10081
SPISettings() {
101-
#if defined (STM32F0xx) || defined(STM32F3xx)
102-
clk = SPI_SPEED_CLOCK_DIV64_MHZ;
103-
#else
104-
clk = SPI_SPEED_CLOCK_DIV16_MHZ;
105-
#endif
82+
clk = SPI_SPEED_CLOCK_DEFAULT;
10683
bOrder = MSBFIRST;
10784
msb = 1;
10885
dMode = SPI_MODE_0;
@@ -125,7 +102,7 @@ class SPISettings {
125102
class SPIClass {
126103
public:
127104
SPIClass();
128-
SPIClass(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t ssel);
105+
SPIClass(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t ssel = 0xFF);
129106

130107
// Transfer functions
131108
byte transfer(byte _pin, uint8_t _data, SPITransferMode _mode = SPI_LAST);

0 commit comments

Comments
 (0)
Please sign in to comment.