feat(SPI): remove skip receive from SPISettings

This parameter should not be part of SPISettings.
Now, SPISettings fully match ArduinoCore-API definition.

Signed-off-by: Frederic Pillon <frederic.pillon@st.com>

Author: fpistm

libraries/SPI/README.md

@@ -7,10 +7,6 @@ User have 2 possibilities about the management of the CS pin:
 * the CS pin is managed directly by the user code before to transfer the data (like the Arduino SPI library)
 * the user uses a hardware CS pin linked to the SPI peripheral
 
-### New SPISetting parameter
-
-* `noReceive`: value can be `SPI_TRANSMITRECEIVE` or `SPI_TRANSMITONLY`. It allows to skip receive data after transmitting. Default `SPI_TRANSMITRECEIVE`.
-
 ### New API functions
 
 * `SPIClass::SPIClass(uint8_t mosi, uint8_t miso, uint8_t sclk, uint8_t ssel)`: alternative class constructor
@@ -21,7 +17,6 @@ _Params_ (optional) SPI `ssel` pin. This pin must be an hardware CS pin. If you
 
  * `SPI_HandleTypeDef *getHandle(void)`: Could be used to mix Arduino API and STM32Cube HAL API (ex: DMA). **Use at your own risk.**
 
-
 ##### Example
 
 This is an example of the use of the hardware CS pin linked to the SPI peripheral:

libraries/SPI/src/SPI.cpp

@@ -162,7 +162,7 @@ void SPIClass::setClockDivider(uint8_t _divider)
   */
 uint8_t SPIClass::transfer(uint8_t data)
 {
-  spi_transfer(&_spi, &data, sizeof(uint8_t), SPI_TRANSFER_TIMEOUT, _spiSettings.getSkipRecv());
+  spi_transfer(&_spi, &data, sizeof(uint8_t), SPI_TRANSFER_TIMEOUT, false);
   return data;
 }
 
@@ -181,7 +181,7 @@ uint16_t SPIClass::transfer16(uint16_t data)
     data = tmp;
   }
   spi_transfer(&_spi, (uint8_t *)&data, sizeof(uint16_t),
-               SPI_TRANSFER_TIMEOUT, _spiSettings.getSkipRecv());
+               SPI_TRANSFER_TIMEOUT, false);
 
   if (_spiSettings.getBitOrder()) {
     tmp = ((data & 0xff00) >> 8) | ((data & 0xff) << 8);
@@ -202,7 +202,7 @@ void SPIClass::transfer(void *buf, size_t count)
 {
   if ((count != 0) && (buf != NULL)) {
     spi_transfer(&_spi, ((uint8_t *)buf), count,
-                 SPI_TRANSFER_TIMEOUT, _spiSettings.getSkipRecv());
+                 SPI_TRANSFER_TIMEOUT, false);
   }
 }
 

libraries/SPI/src/SPI.h

@@ -38,46 +38,42 @@ extern "C" {
 #define SPI_CLOCK_DIV64  64
 #define SPI_CLOCK_DIV128 128
 
-#define SPI_TRANSMITRECEIVE 0x0
-#define SPI_TRANSMITONLY 0x1
-
 // Defines a default timeout delay in milliseconds for the SPI transfer
 #ifndef SPI_TRANSFER_TIMEOUT
   #define SPI_TRANSFER_TIMEOUT 1000
 #endif
 
 class SPISettings {
   public:
-    SPISettings(uint32_t clock, BitOrder bitOrder, SPIMode dataMode, bool skipRecv = SPI_TRANSMITRECEIVE)
+    SPISettings(uint32_t clock, BitOrder bitOrder, SPIMode dataMode)
     {
       if (__builtin_constant_p(clock)) {
-        init_AlwaysInline(clock, bitOrder, dataMode, skipRecv);
+        init_AlwaysInline(clock, bitOrder, dataMode);
       } else {
-        init_MightInline(clock, bitOrder, dataMode, skipRecv);
+        init_MightInline(clock, bitOrder, dataMode);
       }
     }
 
-    SPISettings(uint32_t clock, BitOrder bitOrder, int dataMode, bool skipRecv = SPI_TRANSMITRECEIVE)
+    SPISettings(uint32_t clock, BitOrder bitOrder, int dataMode)
     {
       if (__builtin_constant_p(clock)) {
-        init_AlwaysInline(clock, bitOrder, (SPIMode)dataMode, skipRecv);
+        init_AlwaysInline(clock, bitOrder, (SPIMode)dataMode);
       } else {
-        init_MightInline(clock, bitOrder, (SPIMode)dataMode, skipRecv);
+        init_MightInline(clock, bitOrder, (SPIMode)dataMode);
       }
     }
 
     // Default speed set to 4MHz, SPI mode set to MODE 0 and Bit order set to MSB first.
     SPISettings()
     {
-      init_AlwaysInline(SPI_SPEED_CLOCK_DEFAULT, MSBFIRST, SPI_MODE0, SPI_TRANSMITRECEIVE);
+      init_AlwaysInline(SPI_SPEED_CLOCK_DEFAULT, MSBFIRST, SPI_MODE0);
     }
 
     bool operator==(const SPISettings &rhs) const
     {
       if ((this->clockFreq == rhs.clockFreq) &&
           (this->bitOrder == rhs.bitOrder) &&
-          (this->dataMode == rhs.dataMode) &&
-          (this->skipRecv == rhs.skipRecv)) {
+          (this->dataMode == rhs.dataMode)) {
         return true;
       }
       return false;
@@ -100,11 +96,6 @@ class SPISettings {
     {
       return (bitOrder);
     }
-    bool getSkipRecv() const
-    {
-      return skipRecv;
-    }
-
     void setClockFreq(uint32_t clkFreq)
     {
       clockFreq = clkFreq;
@@ -117,30 +108,24 @@ class SPISettings {
     {
       bitOrder = order;
     }
-    void setSkipRecv(bool skip)
-    {
-      skipRecv = skip;
-    }
 
   private:
-    void init_MightInline(uint32_t clock, BitOrder bitOrder, SPIMode dataMode, bool skipRecv)
+    void init_MightInline(uint32_t clock, BitOrder bitOrder, SPIMode dataMode)
     {
-      init_AlwaysInline(clock, bitOrder, dataMode, skipRecv);
+      init_AlwaysInline(clock, bitOrder, dataMode);
     }
 
     // Core developer MUST use an helper function in beginTransaction() to use this data
-    void init_AlwaysInline(uint32_t clock, BitOrder bitOrder, SPIMode dataMode, bool skipRecv) __attribute__((__always_inline__))
+    void init_AlwaysInline(uint32_t clock, BitOrder bitOrder, SPIMode dataMode) __attribute__((__always_inline__))
     {
       this->clockFreq = clock;
       this->dataMode = dataMode;
       this->bitOrder = bitOrder;
-      this->skipRecv = skipRecv;
     }
 
     uint32_t clockFreq;
     SPIMode dataMode;
     BitOrder bitOrder;
-    bool skipRecv;
 
     friend class HardwareSPI;
 };