all Spi::transfer(...) received bit-resolution

Author: TomSaw

src/modm/math/utils/integer_traits.hpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021, Thomas Sommer
+ *
+ * This file is part of the modm project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <limits>
+#include <type_traits>
+
+#include <cmath>
+namespace modm
+{
+	template <int Bits>
+	struct uint_t
+	{
+		using least = std::conditional_t<
+			(Bits <= 8),uint8_t, std::conditional_t<
+			(Bits <= 16), uint16_t, std::conditional_t<
+			(Bits <= 32), uint32_t, std::enable_if_t<
+			(Bits <= 64), uint64_t>>>>;
+	};
+
+	template<int Bits>
+	using least_uint = typename modm::uint_t<Bits>::least;
+}

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/stm32/module.lb

@@ -29,7 +29,10 @@ class Instance(Module):
         module.description = "Instance {}".format(self.instance)
 
     def prepare(self, module, options):
-        module.depends(":platform:spi")
+        module.depends(
+			":platform:spi",
+			":math:utils"
+		)
         return True
 
     def build(self, env):
@@ -43,6 +46,7 @@ class Instance(Module):
         env.template("spi_hal_impl.hpp.in", "spi_hal_{}_impl.hpp".format(self.instance))
         env.template("spi_master.hpp.in", "spi_master_{}.hpp".format(self.instance))
         env.template("spi_master.cpp.in", "spi_master_{}.cpp".format(self.instance))
+        env.template("spi_master_impl.hpp.in", "spi_master_{}_impl.hpp".format(self.instance))
         if env.has_module(":platform:dma"):
             env.template("spi_master_dma.hpp.in", "spi_master_{}_dma.hpp".format(self.instance))
             env.template("spi_master_dma_impl.hpp.in", "spi_master_{}_dma_impl.hpp".format(self.instance))

src/modm/platform/spi/stm32/spi_hal.hpp.in

@@ -3,6 +3,7 @@
  * Copyright (c) 2013-2018, Niklas Hauser
  * Copyright (c) 2014, Daniel Krebs
  * Copyright (c) 2020, Mike Wolfram
+ * Copyright (c) 2021, Thomas Sommer
  *
  * This file is part of the modm project.
  *
@@ -65,6 +66,10 @@ public:
 	static void
 	setDataSize(DataSize dataSize);
 
+	template<int Bits = 8>
+	static void
+	setDataSize();
+
 	static void
 	setMasterSelection(MasterSelection masterSelection);
 
@@ -82,24 +87,24 @@ public:
 	isTransmitRegisterEmpty();
 
 	/**
-	 * Write up to 16 Bit to the data register
+	 * Write up to 8 Bit to the data register
 	 *
 	 * @warning 	This method does NOT do any sanity checks!!
 	 *				It is your responsibility to check if the register
 	 *				is empty!
 	 */
 	static void
-	write(uint16_t data);
+	write(uint8_t data);
 
 	/**
-	 * Write 8 Bit to the data register
+	 * Write up to 16 Bit to the data register
 	 *
 	 * @warning 	This method does NOT do any sanity checks!!
 	 *				It is your responsibility to check if the register
 	 *				is empty!
 	 */
 	static void
-	write(uint8_t data);
+	write(uint16_t data);
 
 	/**
 	 * Returns the value of the data register

src/modm/platform/spi/stm32/spi_hal_impl.hpp.in

@@ -3,6 +3,7 @@
  * Copyright (c) 2013-2017, Niklas Hauser
  * Copyright (c) 2014, Daniel Krebs
  * Copyright (c) 2020, Mike Wolfram
+ * Copyright (c) 2021, Thomas Sommer
  *
  * This file is part of the modm project.
  *
@@ -90,6 +91,15 @@ modm::platform::SpiHal{{ id }}::setDataSize(DataSize dataSize)
 %% endif
 }
 
+template<int Bits>
+void
+modm::platform::SpiHal{{ id }}::setDataSize()
+{
+	static_assert(Bits >= 4, "Spi DataSize requires at least 4 bits (on this MCU)");
+	static_assert(Bits <= 16, "Spi DataSize is limited to 16 bits (on this MCU)");
+	setDataSize((SpiBase::DataSize)((Bits - 1) << 8));
+}
+
 void inline
 modm::platform::SpiHal{{ id }}::setMasterSelection(MasterSelection masterSelection)
 {
@@ -119,12 +129,6 @@ modm::platform::SpiHal{{ id }}::isTransmitRegisterEmpty()
 	return static_cast<bool>(getInterruptFlags() & InterruptFlag::TxBufferEmpty);
 }
 
-void inline
-modm::platform::SpiHal{{ id }}::write(uint16_t data)
-{
-	SPI{{ id }}->DR = data;
-}
-
 void inline
 modm::platform::SpiHal{{ id }}::write(uint8_t data)
 {
@@ -136,6 +140,12 @@ modm::platform::SpiHal{{ id }}::write(uint8_t data)
 
 }
 
+void inline
+modm::platform::SpiHal{{ id }}::write(uint16_t data)
+{
+	SPI{{ id }}->DR = data;
+}
+
 void inline
 modm::platform::SpiHal{{ id }}::read(uint8_t &data)
 {

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

@@ -5,6 +5,7 @@
  * Copyright (c) 2012-2017, Niklas Hauser
  * Copyright (c) 2013, Kevin Läufer
  * Copyright (c) 2014, Sascha Schade
+ * Copyright (c) 2021, Thomas Sommer
  *
  * This file is part of the modm project.
  *
@@ -24,6 +25,9 @@ modm::platform::SpiMaster{{ id }}::state(0);
 uint8_t
 modm::platform::SpiMaster{{ id }}::count(0);
 
+std::size_t
+modm::platform::SpiMaster{{ id }}::index(0);
+
 void *
 modm::platform::SpiMaster{{ id }}::context(nullptr);
 
@@ -61,85 +65,4 @@ modm::platform::SpiMaster{{ id }}::release(void *ctx)
 			context = nullptr;
 	}
 	return count;
-}
-// ----------------------------------------------------------------------------
-
-modm::ResumableResult<uint8_t>
-modm::platform::SpiMaster{{ id }}::transfer(uint8_t data)
-{
-	// 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 (LSB of state):
-	//   1. waiting to start, and
-	//   2. waiting to finish.
-
-	// LSB != Bit0 ?
-	if ( !(state & Bit0) )
-	{
-		// wait for previous transfer to finish
-		if (!SpiHal{{ id }}::isTransmitRegisterEmpty())
-			return {modm::rf::Running};
-
-		// start transfer by copying data into register
-		SpiHal{{ id }}::write(data);
-
-		// set LSB = Bit0
-		state |= Bit0;
-	}
-
-	if (!SpiHal{{ id }}::isReceiveRegisterNotEmpty())
-		return {modm::rf::Running};
-
-	SpiHal{{ id }}::read(data);
-
-	// transfer finished
-	state &= ~Bit0;
-	return {modm::rf::Stop, data};
-}
-
-modm::ResumableResult<void>
-modm::platform::SpiMaster{{ id }}::transfer(
-		const uint8_t * tx, uint8_t * rx, std::size_t length)
-{
-	// 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 (Bit1 of state):
-	//   1. initialize index, and
-	//   2. wait for 1-byte transfer to finish.
-
-	// we need to globally remember which byte we are currently transferring
-	static std::size_t index = 0;
-
-	// we are only interested in Bit1
-	switch(state & Bit1)
-	{
-		case 0:
-			// we will only visit this state once
-			state |= Bit1;
-
-			// initialize index and check range
-			index = 0;
-			while (index < length)
-			{
-		default:
-		{
-				// if tx == 0, we use a dummy byte 0x00
-				// else we copy it from the array
-				// 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++;
-			}
-
-			// clear the state
-			state &= ~Bit1;
-			return {modm::rf::Stop};
-	}
-}
+}