added uint16_t support to Spi::transfer(...) for STM32 and AVR

Author: TomSaw

src/modm/platform/dma/stm32/dma.hpp.in

@@ -189,6 +189,34 @@ public:
 			ChannelHal::setPeripheralAddress(address);
 		}
 
+				static void
+		setMemoryDataSize(MemoryDataSize memoryDataSize)
+		{
+			ChannelHal::setMemoryDataSize(memoryDataSize);
+		}
+
+		static void
+		setPeripheralDataSize(PeripheralDataSize peripheralDataSize)
+		{
+			ChannelHal::setPeripheralDataSize(peripheralDataSize);
+		}
+
+		template<std::unsigned_integral T>
+		static void
+		configureDataSize() {
+			if constexpr(std::is_same<T, uint8_t>::value) {
+				ChannelHal::setMemoryDataSize(DmaBase::MemoryDataSize::Byte);
+				ChannelHal::setPeripheralDataSize(DmaBase::PeripheralDataSize::Byte);
+			}
+			else if constexpr(std::is_same<T, uint16_t>::value) {
+				ChannelHal::setMemoryDataSize(DmaBase::MemoryDataSize::HalfWord);
+				ChannelHal::setPeripheralDataSize(DmaBase::PeripheralDataSize::HalfWord);
+			} else if constexpr(std::is_same<T, uint32_t>::value) {
+				ChannelHal::setMemoryDataSize(DmaBase::MemoryDataSize::Word);
+				ChannelHal::setPeripheralDataSize(DmaBase::PeripheralDataSize::Word);
+			}
+		}
+
 		/**
 		 * Enable/disable memory increment
 		 *

src/modm/platform/dma/stm32/dma_base.hpp.in

@@ -152,6 +152,7 @@ public:
 		Bit16 		= HalfWord,
 		Word 		= {{ reg_prefix }}_MSIZE_1,
 		Bit32 		= Word,
+		All			= DMA_CCR_MSIZE_0 | DMA_CCR_MSIZE_1
 	};
 
 	enum class
@@ -163,6 +164,7 @@ public:
 		Bit16 		= HalfWord,
 		Word 		= {{ reg_prefix }}_PSIZE_1,
 		Bit32 		= Word,
+		All			= DMA_CCR_PSIZE_0 | DMA_CCR_PSIZE_1
 	};
 
 	enum class

src/modm/platform/dma/stm32/dma_hal.hpp.in

@@ -200,6 +200,22 @@ public:
 		Base->CPAR = address;
 	}
 
+	static void
+	setMemoryDataSize(MemoryDataSize memoryDataSize)
+	{
+		DMA_Channel_TypeDef *Base = (DMA_Channel_TypeDef *) CHANNEL_BASE;
+		Base->CCR &= ~uint32_t(MemoryDataSize::All);
+		Base->CCR |= uint32_t(memoryDataSize);
+	}
+
+	static void
+	setPeripheralDataSize(PeripheralDataSize peripheralDataSize)
+	{
+		DMA_Channel_TypeDef *Base = (DMA_Channel_TypeDef *) CHANNEL_BASE;
+		Base->CCR &= ~uint32_t(PeripheralDataSize::All);
+		Base->CCR |= uint32_t(peripheralDataSize);
+	}
+
 	/**
 	 * Enable/disable memory increment
 	 *
@@ -240,9 +256,11 @@ public:
 
 	/**
 	 * Set length of data to transfer
+	 *
+	 * @param lenght	range: 0-65535
 	 */
 	static void
-	setDataLength(std::size_t length)
+	setDataLength(uint16_t length)
 	{
 		DMA_Channel_TypeDef *Base = (DMA_Channel_TypeDef *) CHANNEL_BASE;
 		Base->CNDTR = length;

src/modm/platform/spi/at90_tiny_mega/module.lb

@@ -50,6 +50,7 @@ class Instance(Module):
 
         env.template("spi.hpp.in", "spi{}.hpp".format(self.instance))
         env.template("spi_master.hpp.in", "spi_master{}.hpp".format(self.instance))
+        env.template("spi_master_impl.hpp.in", "spi_master{}_impl.hpp".format(self.instance))
         env.template("spi_master.cpp.in", "spi_master{}.cpp".format(self.instance))
 
 def init(module):

src/modm/platform/spi/at90_tiny_mega/spi_master.cpp.in

@@ -19,12 +19,16 @@
 #include <modm/math/utils/bit_constants.hpp>
 #include <modm/architecture/interface/atomic_lock.hpp>
 
-// bit 7 (0x80) is used for transfer 1 byte
-// bit 6 (0x40) is used for transfer multiple byte
-// bit 5-0 (0x3f) are used to store the acquire count
+// bit 7 (0x80) is used for transfer 2nd byte
+// bit 6 (0x40) is used for transfer 1th byte
+// bit 5 (0x20) is used for transfer multiple T
+// bit 4-0 (0x1f) are used to store the acquire count
 uint8_t
 modm::platform::SpiMaster{{ id }}::state(0);
 
+uint8_t
+modm::platform::SpiMaster::read(0);
+
 void *
 modm::platform::SpiMaster{{ id }}::context(nullptr);
 
@@ -39,7 +43,7 @@ modm::platform::SpiMaster{{ id }}::initialize(Prescaler prescaler)
 
 	SPCR{{ id }} = (1 << SPE{{ id }}) | (1 << MSTR{{ id }}) | (static_cast<uint8_t>(prescaler) & ~0x80);
 	SPSR{{ id }} = (static_cast<uint8_t>(prescaler) & 0x80) ? (1 << SPI2X{{ id }}) : 0;
-	state &= 0x3f;
+	state &= 0x1f;
 }
 // ----------------------------------------------------------------------------
 
@@ -49,7 +53,7 @@ modm::platform::SpiMaster{{ id }}::acquire(void *ctx, ConfigurationHandler handl
 	if (context == nullptr)
 	{
 		context = ctx;
-		state = (state & ~0x3f) | 1;
+		state = (state & ~0x1f) | 1;
 		// if handler is not nullptr and is different from previous configuration
 		if (handler and configuration != handler) {
 			configuration = handler;
@@ -59,7 +63,7 @@ modm::platform::SpiMaster{{ id }}::acquire(void *ctx, ConfigurationHandler handl
 	}
 
 	if (ctx == context)
-		return (++state & 0x3f);
+		return (++state & 0x1f);
 
 	return 0;
 }
@@ -69,15 +73,15 @@ modm::platform::SpiMaster{{ id }}::release(void *ctx)
 {
 	if (ctx == context)
 	{
-		if ((--state & 0x3f) == 0)
+		if ((--state & 0x1f) == 0)
 			context = nullptr;
 	}
-	return (state & 0x3f);
+	return (state & 0x1f);
 }
 // ----------------------------------------------------------------------------
 
 modm::ResumableResult<uint8_t>
-modm::platform::SpiMaster{{ id }}::transfer(uint8_t data)
+modm::platform::SpiMaster{{ id }}::transfer(const uint8_t data)
 {
 %% if options["busywait"]
 	SPDR{{ id }} = data;
@@ -95,75 +99,82 @@ modm::platform::SpiMaster{{ id }}::transfer(uint8_t data)
 	//   1. waiting to start, and
 	//   2. waiting to finish.
 
-	// MSB != Bit7 ?
-	if ( !(state & Bit7) )
+	// MSB != Bit6 ?
+	if ( !(state & Bit6) )
 	{
 		// start transfer by copying data into register
 		SPDR{{ id }} = data;
 
-		// set MSB = Bit7
-		state |= Bit7;
+		// set MSB = Bit6
+		state |= Bit6;
 	}
 
 	// wait for transfer to finish
 	if (!(SPSR{{ id }} & (1 << SPIF{{ id }})))
 		return {modm::rf::Running};
 
-	data = SPDR{{ id }};
-	state &= ~Bit7;
-	return {modm::rf::Stop, data};
+	state &= ~Bit6;
+	return {modm::rf::Stop, SPDR{{ id }}};
 %% endif
 }
 
-modm::ResumableResult<void>
-modm::platform::SpiMaster{{ id }}::transfer(const uint8_t *tx, uint8_t *rx, std::size_t length)
+modm::ResumableResult<uint16_t>
+modm::platform::SpiMaster{{ id }}::transfer(const uint16_t data)
 {
 %% if options["busywait"]
-	for (std::size_t index = 0; index < length; index++)
-	{
-		modm::ResumableResult<uint8_t> result = transfer(tx ? tx[index] : 0);
-		if (rx) rx[index] = result.getResult();
-	}
-	return {modm::rf::Stop};
+	SPDR{{ id }} = data >> 8;
+
+	// wait for 1rd byte to finish
+	while (!(SPSR{{ id }} & (1 << SPIF{{ id }})))
+		;
+
+	read = SPDR{{ id }} << 8;
+
+	SPDR{{ id }} = data;
+
+	// wait for 2nd byte to finish
+	while (!(SPSR{{ id }} & (1 << SPIF{{ id }})))
+		;
+
+	return {modm::rf::Stop, (uint16_t(read) << 8) | SPDR{{ id }}};
 %% else
 	// this is a manually implemented "fast resumable function"
 	// there is no context or nesting protection, since we don't need it.
-	// there are only two states encoded into 1 bit (Bit6 of state):
-	//   1. initialize index, and
-	//   2. wait for 1-byte transfer to finish.
+	// there are only three states encoded into 1 bit (LSB of state):
+	//   1. waiting to start, and
+	//   2. waiting to finish.
 
-	// we need to globally remember which byte we are currently transferring
-	static std::size_t index = 0;
+	// MSB != Bit6 ?
+	if ( !(state & Bit6) )
+	{
+		// start transfer by copying data into register
+		SPDR{{ id }} = data >> 8;
 
-	// we are only interested in Bit6
-	switch(state & Bit6)
+		// set MSB = Bit6
+		state |= Bit6;
+	}
+	// MSB != Bit7 ?
+	if ( !(state & Bit7) )
 	{
-		case 0:
-			// we will only visit this state once
-			state |= Bit6;
-
-			// initialize index and check range
-			index = 0;
-			while (index < length)
-			{
-		default:
-		{
-				// call the resumable function
-				modm::ResumableResult<uint8_t> result = transfer(tx ? tx[index] : 0);
-
-				// if the resumable function is still running, so are we
-				if (result.getState() > modm::rf::NestingError)
-					return {modm::rf::Running};
-
-				// if rx != 0, we copy the result into the array
-				if (rx) rx[index] = result.getResult();
-		}
-				index++;
-			}
+		// wait for 1rd byte to finish
+		if (!(SPSR{{ id }} & (1 << SPIF{{ id }})))
+			return {modm::rf::Running};
 
-			// clear the state
-			state &= ~Bit6;
-			return {modm::rf::Stop};
+		// store 1rd received byte
+		read = SPDR;
+
+		// start transfer by copying data into register
+		SPDR{{ id }} = data;
+
+		// set MSB = Bit7
+		state |= Bit7;
 	}
+
+	// wait for 2nd byte to finish
+	if (!(SPSR{{ id }} & (1 << SPIF{{ id }})))
+		return {modm::rf::Running};
+
+	state &= ~(Bit7 | Bit6);
+	return {modm::rf::Stop, (uint16_t(read) << 8) | SPDR{{ id }}};
 %% endif
-}
+}

src/modm/platform/spi/at90_tiny_mega/spi_master.hpp.in

@@ -53,6 +53,7 @@ namespace platform
 class SpiMaster{{ id }} : public ::modm::SpiMaster, private Spi
 {
 	static uint8_t state;
+	static uint8_t read;
 	static void *context;
 	static ConfigurationHandler configuration;
 public:
@@ -129,8 +130,9 @@ public:
 	release(void *ctx);
 
 
-	static uint8_t
-	transferBlocking(uint8_t data)
+	template <std::unsigned_integral T>
+	static T
+	transferBlocking(const T data)
 	{
 %% if options["busywait"]
 		return transfer(data).getResult();
@@ -139,22 +141,27 @@ public:
 %% endif
 	}
 
+	template <std::unsigned_integral T>
 	static void
-	transferBlocking(const uint8_t *tx, uint8_t *rx, std::size_t length)
+	transferBlocking(const T *tx, T *rx, std::size_t length)
 	{
 %% if options["busywait"]
 		transfer(tx, rx, length);
 %% else
-		RF_CALL_BLOCKING(transfer(tx, rx, length));
+		RF_CALL_BLOCKING(transfer<T>(tx, rx, length));
 %% endif
 	}
 
 
 	static modm::ResumableResult<uint8_t>
-	transfer(uint8_t data);
+	transfer(const uint8_t data);
+
+	static modm::ResumableResult<uint16_t>
+	transfer(const uint16_t data);
 
+ 	template <std::unsigned_integral T>
 	static modm::ResumableResult<void>
-	transfer(const uint8_t *tx, uint8_t *rx, std::size_t length);
+	transfer(const T *tx, T *rx, std::size_t length);
 	// end documentation inherited
 
 protected:
@@ -166,4 +173,6 @@ protected:
 
 } // namespace modm
 
+#include "spi_master_impl.hpp"
+
 #endif // MODM_AVR_SPI_MASTER_HPP