Implemented SPI for Arduino and a few fixes

src/bus/spi/settings.cpp

@@ -12,11 +12,11 @@ namespace sta
         {
         case SPIMode::MODE_0:
         case SPIMode::MODE_1:
-            return SPIClkPolarity::LOW;
+            return SPIClkPolarity::SPI_LOW;
 
         case SPIMode::MODE_2:
         case SPIMode::MODE_3:
-            return SPIClkPolarity::HIGH;
+            return SPIClkPolarity::SPI_HIGH;
 
         default:
             // Unreachable case
@@ -46,7 +46,7 @@ namespace sta
 
     SPIMode getSPIMode(SPIClkPolarity polarity, SPIClkPhase phase)
     {
-        if (polarity == SPIClkPolarity::LOW)
+        if (polarity == SPIClkPolarity::SPI_LOW)
         {
             if (phase == SPIClkPhase::EDGE_1)
             {

src/debug/printing/printable_serial.cpp

@@ -7,7 +7,7 @@
 namespace sta
 {
     PrintableSerial::PrintableSerial(unsigned long baud)
-        : BasePrintable()
+        : Printable{}
     {
         Serial.begin(baud);
     }

src/devices/arduino/bus/i2c.cpp

@@ -15,28 +15,28 @@ namespace sta
 
     void ArduinoI2C::transfer(uint8_t value)
     {
-        Wire.beginTransmission(address_);
+        Wire.beginTransmission((uint8_t)address_);
         Wire.write(value);
         Wire.endTransmission(true);
     }
 
     void ArduinoI2C::transfer16(uint16_t value)
     {
-        Wire.beginTransmission(address_);
+        Wire.beginTransmission((uint8_t)address_);
         Wire.write(value);
         Wire.endTransmission(true);
     }
 
     void ArduinoI2C::transfer(const uint8_t * buffer, size_t size)
     {
-        Wire.beginTransmission(address_);
+        Wire.beginTransmission((uint8_t)address_);
         Wire.write(buffer, size);
         Wire.endTransmission();
     }
 
     void ArduinoI2C::receive(uint8_t * buffer, size_t size)
     {
-        Wire.requestFrom(address_, size);
+        Wire.requestFrom((uint8_t)address_, (uint8_t)size);
         size_t index = 0;
 
         while (index < size)
@@ -54,7 +54,7 @@ namespace sta
         uint8_t *buffer = new uint8_t[count];
         memset(buffer, value, count);
 
-        Wire.beginTransmission(address_);
+        Wire.beginTransmission((uint8_t)address_);
         Wire.write(buffer, count);
         Wire.endTransmission();
 

src/devices/arduino/bus/spi.cpp

@@ -1,51 +1,102 @@
 #include <sta/devices/arduino/bus/spi.hpp>
 
+#include <sta/lang.hpp>
+
+#include <sta/devices/arduino/hal.hpp>
 
 namespace sta
 {
     ArduinoSPI::ArduinoSPI(const SPISettings & settings, Mutex * mutex /* = nullptr */)
         : SPI{ settings, mutex }
     {
-
+        SPIClass::begin();
     }
 
     void ArduinoSPI::transfer(uint8_t value)
     {
-
+        SPIClass::transfer(value);
     }
 
     void ArduinoSPI::transfer16(uint16_t value)
     {
-
+        SPIClass::transfer16(value);
     }
 
     void ArduinoSPI::transfer(const uint8_t * buffer, size_t size)
     {
+        // We have to create a temporary buffer here because the buffer argument in SPIClass::transfer is not const.
+        uint8_t temp_buffer[size];
+        memcpy(temp_buffer, buffer, size);
 
+        SPIClass::transfer(temp_buffer, size);
     }
 
     void ArduinoSPI::transfer(const uint8_t * txBuffer, uint8_t * rxBuffer, size_t size)
     {
+        // Copy txBuffer content into rxBuffer, SPIClass::transfer will store received values in rxBuffer.
+        memcpy(rxBuffer, txBuffer, size);
 
+        SPIClass::transfer(rxBuffer, size);
     }
 
     void ArduinoSPI::receive(uint8_t * buffer, size_t size)
     {
-
+        SPIClass::transfer(buffer, size);
     }
 
     void ArduinoSPI::fill(uint8_t value, size_t count) 
     {
+        uint8_t temp_buffer[count];
+        memset(temp_buffer, value, count);
 
+        SPIClass::transfer(temp_buffer, count);
     }
 
     void ArduinoSPI::acquire()
     {
+        const SPISettings & set = settings();
 
+        uint8_t dataMode;
+        switch (set.mode)
+        {
+        case SPIMode::MODE_0:
+            dataMode = SPI_MODE0;
+            break;
+        case SPIMode::MODE_1:
+            dataMode = SPI_MODE1;
+            break;
+        case SPIMode::MODE_2:
+            dataMode = SPI_MODE2;
+            break;
+        case SPIMode::MODE_3:
+            dataMode = SPI_MODE3;
+            break;        
+        default:
+            STA_UNREACHABLE();
+            break;
+        }
+
+        uint8_t bitOrder;
+        switch (set.bitOrder)
+        {
+        case SPIBitOrder::MSB:
+            bitOrder = MSBFIRST;
+            break;
+        case SPIBitOrder::LSB:
+            bitOrder = LSBFIRST;
+            break;
+        default:
+            STA_UNREACHABLE();
+            break;
+        }
+
+        hal::SPISettings halSettings(set.clkSpeed, bitOrder, dataMode);
+
+        SPIClass::beginTransaction(halSettings);
     }
 
     void ArduinoSPI::release()
     {
-
+        SPIClass::endTransaction();
     }
 } // namespace sta

src/devices/stm32/bus/spi.cpp

@@ -20,7 +20,7 @@ namespace sta
         SPISettings settings;
 
         settings.mode        = getSPIMode(
-            (handle->Init.CLKPolarity == SPI_POLARITY_LOW) ? SPIClkPolarity::LOW : SPIClkPolarity::HIGH,
+            (handle->Init.CLKPolarity == SPI_POLARITY_LOW) ? SPIClkPolarity::SPI_LOW : SPIClkPolarity::SPI_HIGH,
             (handle->Init.CLKPhase == SPI_PHASE_1EDGE) ? SPIClkPhase::EDGE_1 : SPIClkPhase::EDGE_2
         );
         settings.dataSize    = (handle->Init.DataSize == SPI_DATASIZE_8BIT) ? SPIDataSize::SIZE_8 : SPIDataSize::SIZE_16;