chore(spi): partially align with ArduinoCoreAPI

Keep constexpr constructor to ensures that constructing
an SPISettings object can be done at compiletime.

Fixes stm32duino#2201.

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

Author: fpistm

libraries/SPI/src/SPI.cpp

@@ -57,9 +57,10 @@ SPIClass::SPIClass(uint32_t mosi, uint32_t miso, uint32_t sclk, uint32_t ssel)
 void SPIClass::begin(void)
 {
   _spi.handle.State = HAL_SPI_STATE_RESET;
-  spi_init(&_spi, _spiSettings.clk,
-           _spiSettings.dMode,
-           _spiSettings.bOrder);
+  _spiSettings = SPISettings();
+  spi_init(&_spi, _spiSettings.clockFreq,
+           _spiSettings.dataMode,
+           _spiSettings.bitOrder);
 }
 
 /**
@@ -69,14 +70,12 @@ void SPIClass::begin(void)
   */
 void SPIClass::beginTransaction(SPISettings settings)
 {
-  _spiSettings.clk = settings.clk;
-  _spiSettings.dMode = settings.dMode;
-  _spiSettings.bOrder = settings.bOrder;
-  _spiSettings.noReceive = settings.noReceive;
-
-  spi_init(&_spi, _spiSettings.clk,
-           _spiSettings.dMode,
-           _spiSettings.bOrder);
+  if (_spiSettings != settings) {
+    _spiSettings = settings;
+    spi_init(&_spi, _spiSettings.clockFreq,
+             _spiSettings.dataMode,
+             _spiSettings.bitOrder);
+  }
 }
 
 /**
@@ -90,71 +89,67 @@ void SPIClass::endTransaction(void)
 /**
   * @brief  Deinitialize the SPI instance and stop it.
   */
-void SPIClass::end()
+void SPIClass::end(void)
 {
   spi_deinit(&_spi);
 }
 
 /**
   * @brief  Deprecated function.
   *         Configure the bit order: MSB first or LSB first.
-  * @param  _bitOrder: MSBFIRST or LSBFIRST
+  * @param  bitOrder: MSBFIRST or LSBFIRST
   */
 void SPIClass::setBitOrder(BitOrder bitOrder)
 {
-  _spiSettings.bOrder = bitOrder;
+  _spiSettings.bitOrder = bitOrder;
 
-  spi_init(&_spi, _spiSettings.clk,
-           _spiSettings.dMode,
-           _spiSettings.bOrder);
+  spi_init(&_spi, _spiSettings.clockFreq,
+           _spiSettings.dataMode,
+           _spiSettings.bitOrder);
 }
 
 /**
   * @brief  Deprecated function.
   *         Configure the data mode (clock polarity and clock phase)
-  * @param  _mode: SPI_MODE0, SPI_MODE1, SPI_MODE2 or SPI_MODE3
+  * @param  mode: SPI_MODE0, SPI_MODE1, SPI_MODE2 or SPI_MODE3
   * @note
   *         Mode          Clock Polarity (CPOL)   Clock Phase (CPHA)
   *         SPI_MODE0             0                     0
   *         SPI_MODE1             0                     1
   *         SPI_MODE2             1                     0
   *         SPI_MODE3             1                     1
   */
-void SPIClass::setDataMode(uint8_t _mode)
+void SPIClass::setDataMode(uint8_t mode)
 {
-  if (SPI_MODE0 == _mode) {
-    _spiSettings.dMode = SPI_MODE_0;
-  } else if (SPI_MODE1 == _mode) {
-    _spiSettings.dMode = SPI_MODE_1;
-  } else if (SPI_MODE2 == _mode) {
-    _spiSettings.dMode = SPI_MODE_2;
-  } else if (SPI_MODE3 == _mode) {
-    _spiSettings.dMode = SPI_MODE_3;
-  }
+  setDataMode((SPIMode)mode);
+}
 
-  spi_init(&_spi, _spiSettings.clk,
-           _spiSettings.dMode,
-           _spiSettings.bOrder);
+void SPIClass::setDataMode(SPIMode mode)
+{
+  _spiSettings.dataMode = mode;
+  spi_init(&_spi, _spiSettings.clockFreq,
+           _spiSettings.dataMode,
+           _spiSettings.bitOrder);
 }
 
 /**
   * @brief  Deprecated function.
   *         Configure the clock speed
-  * @param  _divider: the SPI clock can be divided by values from 1 to 255.
+  * @param  divider: the SPI clock can be divided by values from 1 to 255.
   *         If 0, default SPI speed is used.
   */
-void SPIClass::setClockDivider(uint8_t _divider)
+void SPIClass::setClockDivider(uint8_t divider)
 {
-  if (_divider == 0) {
-    _spiSettings.clk = SPI_SPEED_CLOCK_DEFAULT;
+  if (divider == 0) {
+    _spiSettings.clockFreq = SPI_SPEED_CLOCK_DEFAULT;
   } else {
     /* Get clk freq of the SPI instance and compute it */
-    _spiSettings.clk = spi_getClkFreq(&_spi) / _divider;
+    _spiSettings.clockFreq = spi_getClkFreq(&_spi) / divider;
   }
 
-  spi_init(&_spi, _spiSettings.clk,
-           _spiSettings.dMode,
-           _spiSettings.bOrder);
+  spi_init(&_spi, _spiSettings.clockFreq,
+           _spiSettings.dataMode,
+           _spiSettings.bitOrder);
 }
 
 /**
@@ -163,7 +158,7 @@ void SPIClass::setClockDivider(uint8_t _divider)
   * @param  data: byte to send.
   * @return byte received from the slave.
   */
-byte SPIClass::transfer(uint8_t data)
+uint8_t SPIClass::transfer(uint8_t data)
 {
   spi_transfer(&_spi, &data, sizeof(uint8_t), SPI_TRANSFER_TIMEOUT, _spiSettings.noReceive);
   return data;
@@ -179,14 +174,14 @@ uint16_t SPIClass::transfer16(uint16_t data)
 {
   uint16_t tmp;
 
-  if (_spiSettings.bOrder) {
+  if (_spiSettings.bitOrder) {
     tmp = ((data & 0xff00) >> 8) | ((data & 0xff) << 8);
     data = tmp;
   }
   spi_transfer(&_spi, (uint8_t *)&data, sizeof(uint16_t),
                SPI_TRANSFER_TIMEOUT, _spiSettings.noReceive);
 
-  if (_spiSettings.bOrder) {
+  if (_spiSettings.bitOrder) {
     tmp = ((data & 0xff00) >> 8) | ((data & 0xff) << 8);
     data = tmp;
   }
@@ -197,11 +192,11 @@ uint16_t SPIClass::transfer16(uint16_t data)
 /**
   * @brief  Transfer several bytes. Only one buffer used to send and receive data.
   *         begin() or beginTransaction() must be called at least once before.
-  * @param  _buf: pointer to the bytes to send. The bytes received are copy in
+  * @param  buf: pointer to the bytes to send. The bytes received are copy in
   *         this buffer.
-  * @param  _count: number of bytes to send/receive.
+  * @param  count: number of bytes to send/receive.
   */
-void SPIClass::transfer(void *_buf, size_t _count)
+void SPIClass::transfer(void *buf, size_t count)
 {
   if ((count != 0) && (buf != NULL)) {
     spi_transfer(&_spi, ((uint8_t *)buf), count,
@@ -212,7 +207,15 @@ void SPIClass::transfer(void *_buf, size_t _count)
 /**
   * @brief  Not implemented.
   */
-void SPIClass::usingInterrupt(uint8_t interruptNumber)
+void SPIClass::usingInterrupt(int interruptNumber)
+{
+  UNUSED(interruptNumber);
+}
+
+/**
+  * @brief  Not implemented.
+  */
+void SPIClass::notUsingInterrupt(int interruptNumber)
 {
   UNUSED(interruptNumber);
 }

libraries/SPI/src/SPI.h

@@ -38,12 +38,6 @@ extern "C" {
 #define SPI_CLOCK_DIV64  64
 #define SPI_CLOCK_DIV128 128
 
-// SPI mode parameters for SPISettings
-#define SPI_MODE0 0x00
-#define SPI_MODE1 0x01
-#define SPI_MODE2 0x02
-#define SPI_MODE3 0x03
-
 #define SPI_TRANSMITRECEIVE 0x0
 #define SPI_TRANSMITONLY 0x1
 
@@ -54,35 +48,42 @@ extern "C" {
 
 class SPISettings {
   public:
-    constexpr SPISettings(uint32_t clock, BitOrder bitOrder, uint8_t dataMode, bool noRecv = SPI_TRANSMITRECEIVE)
-      : clk(clock),
-        bOrder(bitOrder),
-        dMode((spi_mode_e)(
-                (SPI_MODE0 == dataMode) ? SPI_MODE_0 :
-                (SPI_MODE1 == dataMode) ? SPI_MODE_1 :
-                (SPI_MODE2 == dataMode) ? SPI_MODE_2 :
-                (SPI_MODE3 == dataMode) ? SPI_MODE_3 :
-                SPI_MODE0
-              )),
+    constexpr SPISettings(uint32_t clock, BitOrder bitOrder, SPIMode dataMode, bool noRecv = SPI_TRANSMITRECEIVE)
+      : clockFreq(clock),
+        bitOrder(bitOrder),
+        dataMode(dataMode),
         noReceive(noRecv)
     { }
     constexpr SPISettings()
-      : clk(SPI_SPEED_CLOCK_DEFAULT),
-        bOrder(MSBFIRST),
-        dMode(SPI_MODE_0),
+      : clockFreq(SPI_SPEED_CLOCK_DEFAULT),
+        bitOrder(MSBFIRST),
+        dataMode(SPI_MODE0),
         noReceive(SPI_TRANSMITRECEIVE)
     { }
+
+    bool operator==(const SPISettings &rhs) const
+    {
+      if ((this->clockFreq == rhs.clockFreq) &&
+          (this->bitOrder == rhs.bitOrder) &&
+          (this->dataMode == rhs.dataMode) &&
+          (this->noReceive == rhs.noReceive)) {
+        return true;
+      }
+      return false;
+    }
+
+    bool operator!=(const SPISettings &rhs) const
+    {
+      return !(*this == rhs);
+    }
+
   private:
-    uint32_t clk;       //specifies the spi bus maximum clock speed
-    BitOrder bOrder;    //bit order (MSBFirst or LSBFirst)
-    spi_mode_e dMode;   //one of the data mode
-    //Mode          Clock Polarity (CPOL)   Clock Phase (CPHA)
-    //SPI_MODE0             0                     0
-    //SPI_MODE1             0                     1
-    //SPI_MODE2             1                     0
-    //SPI_MODE3             1                     1
-    friend class SPIClass;
+    uint32_t clockFreq; //specifies the spi bus maximum clock speed
+    BitOrder bitOrder;  //bit order (MSBFirst or LSBFirst)
+    SPIMode  dataMode;  //one of the data mode
     bool noReceive;
+
+    friend class SPIClass;
 };
 
 class SPIClass {
@@ -125,7 +126,7 @@ class SPIClass {
       _spi.pin_ssel = (ssel);
     };
 
-    virtual void begin();
+    virtual void begin(void);
     void end(void);
 
     /* This function should be used to configure the SPI instance in case you
@@ -137,19 +138,21 @@ class SPIClass {
     /* Transfer functions: must be called after initialization of the SPI
      * instance with begin() or beginTransaction().
      */
-    virtual byte transfer(uint8_t _data);
-    virtual uint16_t transfer16(uint16_t _data);
-    virtual void transfer(void *_buf, size_t _count);
+    virtual uint8_t transfer(uint8_t data);
+    virtual uint16_t transfer16(uint16_t data);
+    virtual void transfer(void *buf, size_t count);
 
     /* These methods are deprecated and kept for compatibility.
      * Use SPISettings with SPI.beginTransaction() to configure SPI parameters.
      */
     void setBitOrder(BitOrder);
     void setDataMode(uint8_t);
+    void setDataMode(SPIMode);
     void setClockDivider(uint8_t);
 
-    // Not implemented functions. Kept for backward compatibility.
-    void usingInterrupt(uint8_t interruptNumber);
+    // Not implemented functions. Kept for compatibility.
+    void usingInterrupt(int interruptNumber);
+    void notUsingInterrupt(int interruptNumber);
     void attachInterrupt(void);
     void detachInterrupt(void);
 

libraries/SPI/src/utility/spi_com.c

@@ -227,7 +227,7 @@ static uint32_t compute_disable_delay(spi_t *obj)
   * @param  msb : set to 1 in msb first
   * @retval None
   */
-void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb)
+void spi_init(spi_t *obj, uint32_t speed, SPIMode mode, uint8_t msb)
 {
   if (obj == NULL) {
     return;
@@ -313,13 +313,13 @@ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb)
 
   handle->Init.Direction         = SPI_DIRECTION_2LINES;
 
-  if ((mode == SPI_MODE_0) || (mode == SPI_MODE_2)) {
+  if ((mode == SPI_MODE0) || (mode == SPI_MODE2)) {
     handle->Init.CLKPhase          = SPI_PHASE_1EDGE;
   } else {
     handle->Init.CLKPhase          = SPI_PHASE_2EDGE;
   }
 
-  if ((mode == SPI_MODE_0) || (mode == SPI_MODE_1)) {
+  if ((mode == SPI_MODE0) || (mode == SPI_MODE1)) {
     handle->Init.CLKPolarity       = SPI_POLARITY_LOW;
   } else {
     handle->Init.CLKPolarity       = SPI_POLARITY_HIGH;

libraries/SPI/src/utility/spi_com.h

@@ -85,12 +85,13 @@ typedef struct spi_s spi_t;
 //SPI_MODE2             1                         0
 //SPI_MODE3             1                         1
 //enum definitions coming from SPI.h of SAM
+// SPI mode parameters for SPISettings
 typedef enum {
-  SPI_MODE_0 = 0x00,
-  SPI_MODE_1 = 0x01,
-  SPI_MODE_2 = 0x02,
-  SPI_MODE_3 = 0x03
-} spi_mode_e;
+  SPI_MODE0 = 0,
+  SPI_MODE1 = 1,
+  SPI_MODE2 = 2,
+  SPI_MODE3 = 3,
+} SPIMode;
 
 ///@brief SPI errors
 typedef enum {
@@ -100,7 +101,7 @@ typedef enum {
 } spi_status_e;
 
 /* Exported functions ------------------------------------------------------- */
-void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb);
+void spi_init(spi_t *obj, uint32_t speed, SPIMode mode, uint8_t msb);
 void spi_deinit(spi_t *obj);
 spi_status_e spi_transfer(spi_t *obj, uint8_t *buffer, uint16_t len,
                           uint32_t Timeout, bool skipReceive);