feat(core): third step of ArduinoCore-API migration – SPI

Signed-off-by: Aymane Bahssain <aymane.bahssain@st.com>

Author: Aymane-ST

CI/build/examples/BareMinimum/BareMinimum.ino

@@ -4,6 +4,7 @@
  * and can not be executed.
  */
 
+#include <SPI.h>
 #include <SoftwareSerial.h>
 #include <Wire.h>
 
@@ -38,7 +39,6 @@ void setup() {
   Serial.begin(9600);  // start serial for output
   while (!Serial) {};
 
-  // Test SoftwareSerial
   swSerial.begin(4800);
   swSerial.println("X");
   delay(20);
@@ -49,7 +49,18 @@ void setup() {
   }
   swSerial.end();
 
-    // Wire
+  // SPI
+  SPISettings settings(SPI_SPEED_CLOCK_DEFAULT, MSBFIRST, SPI_MODE0);
+  SPI.setMISO(PIN_SPI_MISO);
+  SPI.setMOSI(PIN_SPI_MOSI);
+  SPI.setSCLK(PIN_SPI_SCK);
+  SPI.setSSEL(digitalPinToPinName(PIN_SPI_SS));
+  SPI.begin();
+  SPI.beginTransaction(settings);
+  SPI.endTransaction();
+  SPI.transfer(1);
+  SPI.end();
+  // Wire
   Wire.setSCL(PIN_WIRE_SCL);
   Wire.setSDA(digitalPinToPinName(PIN_WIRE_SDA));
   Wire.setClock(400000);

CI/build/examples/BareMinimum/CMakeLists.txt

@@ -47,6 +47,6 @@ build_sketch(TARGET "BareMinimum"
   # IWatchdog
   # Servo
   SoftwareSerial
-  # SPI
+  SPI
   Wire
 )

libraries/SPI/src/SPI.cpp

@@ -11,7 +11,7 @@
 
 #include "SPI.h"
 
-SPIClass SPI;
+::SPIClass SPI;
 
 /**
   * @brief  Default Constructor. Uses pin configuration of default SPI
@@ -35,7 +35,54 @@ SPIClass SPI;
   *         another CS pin and don't pass a CS pin as parameter to any functions
   *         of the class.
   */
-SPIClass::SPIClass(uint32_t mosi, uint32_t miso, uint32_t sclk, uint32_t ssel)
+
+void ::SPIClass::applySettings(const SPISettings &settings)
+{
+  _spiSettings = settings;
+
+  uint32_t  clock   = settings.getClockFreq();
+  SPIMode   dataMode    = settings.getDataMode();
+  BitOrder  order   = settings.getBitOrder();
+  SPIBusMode busMode    = settings.getBusMode();
+
+  // Mapping API dataMode → spi_mode_e C
+  spi_mode_e cspimode;
+  switch (dataMode) {
+    case SPI_MODE0:
+      cspimode = SPI_MODE0_C;
+      break;
+    case SPI_MODE1:
+      cspimode = SPI_MODE1_C;
+      break;
+    case SPI_MODE2:
+      cspimode = SPI_MODE2_C;
+      break;
+    case SPI_MODE3:
+      cspimode = SPI_MODE3_C;
+      break;
+    default:
+      cspimode = SPI_MODE0_C;
+      break;
+  }
+
+  // Mapping API busMode → spi_busmode_e C
+  spi_busmode_e cbusmode;
+  switch (busMode) {
+    case SPI_CONTROLLER:
+      cbusmode = SPI_CONTROLLER_C;
+      break;
+    case SPI_PERIPHERAL:
+      cbusmode = SPI_PERIPHERAL_C;
+      break;
+    default:
+      cbusmode = SPI_CONTROLLER_C;
+      break;
+  }
+
+  spi_init(&_spi, clock, cspimode, (uint8_t)order, cbusmode);
+}
+
+::SPIClass::SPIClass(pin_size_t mosi, pin_size_t miso, pin_size_t sclk, pin_size_t ssel)
 {
   memset((void *)&_spi, 0, sizeof(_spi));
   _spi.pin_miso = digitalPinToPinName(miso);
@@ -46,43 +93,47 @@ SPIClass::SPIClass(uint32_t mosi, uint32_t miso, uint32_t sclk, uint32_t ssel)
 
 /**
   * @brief  Initialize the SPI instance.
-  * @param  device: device mode (optional), SPI_MASTER or SPI_SLAVE. Default is master.
+  * @param  busMode: bus mode (optional), controller or peripheral. Default is master.
   */
-void SPIClass::begin(SPIDeviceMode device)
+void ::SPIClass::begin(SPIBusMode busMode)
 {
   _spi.handle.State = HAL_SPI_STATE_RESET;
-  _spiSettings = SPISettings();
-  _spiSettings.deviceMode = device;
-  spi_init(&_spi, _spiSettings.clockFreq, _spiSettings.dataMode,
-           _spiSettings.bitOrder, _spiSettings.deviceMode);
+
+  SPISettings defaultSettings(
+    SPI_SPEED_CLOCK_DEFAULT, // 4 MHz
+    MSBFIRST,
+    SPI_MODE0,
+    busMode
+  );
+
+  applySettings(defaultSettings);
 }
 
 /**
   * @brief  This function should be used to configure the SPI instance in case you
   *         don't use the default parameters set by the begin() function.
-  * @param  settings: SPI settings(clock speed, bit order, data mode, device mode).
+  * @param  settings: SPI settings(clock speed, bit order, data mode, bus mode).
   */
-void SPIClass::beginTransaction(SPISettings settings)
+void ::SPIClass::beginTransaction(SPISettings settings)
 {
-  if (_spiSettings != settings) {
-    _spiSettings = settings;
-    spi_init(&_spi, _spiSettings.clockFreq, _spiSettings.dataMode,
-             _spiSettings.bitOrder, _spiSettings.deviceMode);
+  if (_spiSettings == settings) {
+    return;
   }
+  applySettings(settings);
 }
 
 /**
   * @brief  End the transaction after beginTransaction usage
   */
-void SPIClass::endTransaction(void)
+void ::SPIClass::endTransaction(void)
 {
 
 }
 
 /**
   * @brief  Deinitialize the SPI instance and stop it.
   */
-void SPIClass::end(void)
+void ::SPIClass::end(void)
 {
   spi_deinit(&_spi);
 }
@@ -92,35 +143,42 @@ void SPIClass::end(void)
   *         Configure the bit order: MSB first or LSB first.
   * @param  bitOrder: MSBFIRST or LSBFIRST
   */
-void SPIClass::setBitOrder(BitOrder bitOrder)
+void ::SPIClass::setBitOrder(BitOrder bitOrder)
 {
-  _spiSettings.bitOrder = bitOrder;
-
-  spi_init(&_spi, _spiSettings.clockFreq, _spiSettings.dataMode,
-           _spiSettings.bitOrder, _spiSettings.deviceMode);
+  SPISettings s(
+    _spiSettings.getClockFreq(),
+    bitOrder,
+    _spiSettings.getDataMode(),
+    _spiSettings.getBusMode()
+  );
+  applySettings(s);
 }
 
 /**
   * @brief  Deprecated function.
   *         Configure the data mode (clock polarity and clock phase)
-  * @param  mode: SPI_MODE0, SPI_MODE1, SPI_MODE2 or SPI_MODE3
+  * @param  dataMode: 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 dataMode)
 {
-  setDataMode((SPIMode)mode);
+  setDataMode((SPIMode)dataMode);
 }
 
-void SPIClass::setDataMode(SPIMode mode)
+void ::SPIClass::setDataMode(SPIMode dataMode)
 {
-  _spiSettings.dataMode = mode;
-  spi_init(&_spi, _spiSettings.clockFreq, _spiSettings.dataMode,
-           _spiSettings.bitOrder, _spiSettings.deviceMode);
+  SPISettings s(
+    _spiSettings.getClockFreq(),
+    _spiSettings.getBitOrder(),
+    dataMode,
+    _spiSettings.getBusMode()
+  );
+  applySettings(s);
 }
 
 /**
@@ -129,17 +187,22 @@ void SPIClass::setDataMode(SPIMode mode)
   * @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)
 {
+  uint32_t clk;
   if (divider == 0) {
-    _spiSettings.clockFreq = SPI_SPEED_CLOCK_DEFAULT;
+    clk = SPI_SPEED_CLOCK_DEFAULT;
   } else {
-    /* Get clk freq of the SPI instance and compute it */
-    _spiSettings.clockFreq = spi_getClkFreq(&_spi) / divider;
+    clk = spi_getClkFreq(&_spi) / divider;
   }
 
-  spi_init(&_spi, _spiSettings.clockFreq, _spiSettings.dataMode,
-           _spiSettings.bitOrder, _spiSettings.deviceMode);
+  SPISettings s(
+    clk,
+    _spiSettings.getBitOrder(),
+    _spiSettings.getDataMode(),
+    _spiSettings.getBusMode()
+  );
+  applySettings(s);
 }
 
 /**
@@ -151,7 +214,7 @@ void SPIClass::setClockDivider(uint8_t divider)
   *         Optional, default: SPI_TRANSMITRECEIVE.
   * @return byte received from the slave.
   */
-uint8_t SPIClass::transfer(uint8_t data, bool skipReceive)
+uint8_t ::SPIClass::transfer(uint8_t data, bool skipReceive)
 {
   spi_transfer(&_spi, &data, (!skipReceive) ? &data : NULL, sizeof(uint8_t));
   return data;
@@ -166,17 +229,17 @@ uint8_t SPIClass::transfer(uint8_t data, bool skipReceive)
   *         Optional, default: SPI_TRANSMITRECEIVE.
   * @return bytes received from the slave in 16 bits format.
   */
-uint16_t SPIClass::transfer16(uint16_t data, bool skipReceive)
+uint16_t ::SPIClass::transfer16(uint16_t data, bool skipReceive)
 {
   uint16_t tmp;
 
-  if (_spiSettings.bitOrder) {
+  if (_spiSettings.getBitOrder()) {
     tmp = ((data & 0xff00) >> 8) | ((data & 0xff) << 8);
     data = tmp;
   }
   spi_transfer(&_spi, (uint8_t *)&data, (!skipReceive) ? (uint8_t *)&data : NULL, sizeof(uint16_t));
 
-  if (_spiSettings.bitOrder) {
+  if (_spiSettings.getBitOrder()) {
     tmp = ((data & 0xff00) >> 8) | ((data & 0xff) << 8);
     data = tmp;
   }
@@ -194,7 +257,7 @@ uint16_t SPIClass::transfer16(uint16_t data, bool skipReceive)
   *         SPI_TRANSMITRECEIVE or SPI_TRANSMITONLY.
   *         Optional, default: SPI_TRANSMITRECEIVE.
   */
-void SPIClass::transfer(void *buf, size_t count, bool skipReceive)
+void ::SPIClass::transfer(void *buf, size_t count, bool skipReceive)
 {
   spi_transfer(&_spi, (uint8_t *)buf, (!skipReceive) ? (uint8_t *)buf : NULL, count);
 
@@ -211,7 +274,7 @@ void SPIClass::transfer(void *buf, size_t count, bool skipReceive)
   *                 the SPI transfer. If NULL, the received data will be discarded.
   * @param  count: number of bytes to send/receive.
   */
-void SPIClass::transfer(const void *tx_buf, void *rx_buf, size_t count)
+void ::SPIClass::transfer(const void *tx_buf, void *rx_buf, size_t count)
 {
   spi_transfer(&_spi, ((const uint8_t *)tx_buf), ((uint8_t *)rx_buf), count);
 }
@@ -220,37 +283,37 @@ void SPIClass::transfer(const void *tx_buf, void *rx_buf, size_t count)
 /**
   * @brief  Not implemented.
   */
-void SPIClass::usingInterrupt(int interruptNumber)
+void ::SPIClass::usingInterrupt(int interruptNumber)
 {
   UNUSED(interruptNumber);
 }
 
 /**
   * @brief  Not implemented.
   */
-void SPIClass::notUsingInterrupt(int interruptNumber)
+void ::SPIClass::notUsingInterrupt(int interruptNumber)
 {
   UNUSED(interruptNumber);
 }
 
 /**
   * @brief  Not implemented.
   */
-void SPIClass::attachInterrupt(void)
+void ::SPIClass::attachInterrupt(void)
 {
   // Should be enableInterrupt()
 }
 
 /**
   * @brief  Not implemented.
   */
-void SPIClass::detachInterrupt(void)
+void ::SPIClass::detachInterrupt(void)
 {
   // Should be disableInterrupt()
 }
 
 #if defined(SUBGHZSPI_BASE)
-void SUBGHZSPIClass::enableDebugPins(uint32_t mosi, uint32_t miso, uint32_t sclk, uint32_t ssel)
+void SUBGHZSPIClass::enableDebugPins(pin_size_t mosi, pin_size_t miso, pin_size_t sclk, pin_size_t ssel)
 {
   /* Configure SPI GPIO pins */
   pinmap_pinout(digitalPinToPinName(mosi), PinMap_SPI_MOSI);