Merge branch 'bit-resolution-Spi' into rewrite-graphics-API

Author: TomSaw

src/modm/driver/display/ili9341_interface_spi.hpp

@@ -26,14 +26,23 @@ template<class SpiMaster, class Cs, class Dc>
 class Ili9341InterfaceSpi : public ili9341_register, public modm::SpiDevice< SpiMaster >, protected modm::NestedResumable<5>
 {
 	uint8_t read;
+	
+	static constexpr auto configuration8bit = []() {
+		SpiMaster::setDataMode(SpiMaster::DataMode::Mode0);
+		SpiMaster::setDataOrder(SpiMaster::DataOrder::MsbFirst);
+		SpiMaster::setDataSize(SpiMaster::DataSize::Bit8);
+	};
+
+	static constexpr auto configuration16bit = []() {
+		SpiMaster::setDataMode(SpiMaster::DataMode::Mode0);
+		SpiMaster::setDataOrder(SpiMaster::DataOrder::MsbFirst);
+		SpiMaster::setDataSize(SpiMaster::DataSize::Bit16);
+	};
+
 protected:
 	Ili9341InterfaceSpi()
 	{
-		this->attachConfigurationHandler([]() {
-			SpiMaster::setDataMode(SpiMaster::DataMode::Mode0);
-			SpiMaster::setDataOrder(SpiMaster::DataOrder::MsbFirst);
-			SpiMaster::setDataSize(SpiMaster::DataSize::Bit16);
-		});
+		this->attachConfigurationHandler(configuration16bit);
 		Cs::setOutput(modm::Gpio::High);
 		Dc::setOutput();
 	}
@@ -47,7 +56,7 @@ class Ili9341InterfaceSpi : public ili9341_register, public modm::SpiDevice< Spi
 		Cs::reset();
 
 		Dc::reset();
-		RF_CALL(SpiMaster::transfer(uint8_t(command)));
+		RF_CALL(SpiMaster::transfer(uint16_t(command))); // It's Ok to send sole commands in 16bit
 		Dc::set();
 
 		if (this->releaseMaster())
@@ -60,6 +69,7 @@ class Ili9341InterfaceSpi : public ili9341_register, public modm::SpiDevice< Spi
 	writeCommand(Command command, const uint8_t data)
 	{
 		RF_BEGIN();
+		this->attachConfigurationHandler(configuration8bit);
 
 		RF_WAIT_UNTIL(this->acquireMaster());
 		Cs::reset();
@@ -73,23 +83,45 @@ class Ili9341InterfaceSpi : public ili9341_register, public modm::SpiDevice< Spi
 		if (this->releaseMaster())
 			Cs::set();
 
+		this->attachConfigurationHandler(configuration16bit);
+		RF_END();
+	}
+
+	modm::ResumableResult<void>
+	writeCommand(Command command, const uint8_t *data, uint16_t length)
+	{
+		RF_BEGIN();
+		this->attachConfigurationHandler(configuration8bit);
+
+		RF_WAIT_UNTIL(this->acquireMaster());
+		Cs::reset();
+
+		Dc::reset();
+		RF_CALL(SpiMaster::transfer(uint8_t(command)));
+		Dc::set();
+
+		RF_CALL(SpiMaster::transfer(data, (uint8_t*)(nullptr), length));
+
+		if (this->releaseMaster())
+			Cs::set();
+
+		this->attachConfigurationHandler(configuration16bit);
 		RF_END();
 	}
 
-	template<std::unsigned_integral T>
 	modm::ResumableResult<void>
-	writeCommand(Command command, const T *data, uint16_t length)
+	writeCommand(Command command, const uint16_t *data, uint16_t length)
 	{
 		RF_BEGIN();
 
 		RF_WAIT_UNTIL(this->acquireMaster());
 		Cs::reset();
 
 		Dc::reset();
-		RF_CALL(SpiMaster::transfer(uint16_t(command)));
+		RF_CALL(SpiMaster::transfer(uint16_t(command))); // It's Ok to send sole commands in 16bit
 		Dc::set();
 
-		RF_CALL(SpiMaster::template transfer<T>(data, nullptr, length));
+		RF_CALL(SpiMaster::transfer(data, (uint16_t*)(nullptr), length));
 
 		if (this->releaseMaster())
 			Cs::set();
@@ -121,7 +153,7 @@ class Ili9341InterfaceSpi : public ili9341_register, public modm::SpiDevice< Spi
 		RF_WAIT_UNTIL(this->acquireMaster());
 		Cs::reset();
 
-		RF_CALL(SpiMaster::template transfer<Rgb565::ValueType>((Rgb565::ValueType*)(pixel), repeat));
+		RF_CALL(SpiMaster::template transfer<uint16_t>((uint16_t*)(pixel), repeat));
 
 		if (this->releaseMaster())
 			Cs::set();
@@ -137,7 +169,7 @@ class Ili9341InterfaceSpi : public ili9341_register, public modm::SpiDevice< Spi
 		RF_WAIT_UNTIL(this->acquireMaster());
 		Cs::reset();
 
-		RF_CALL(SpiMaster::template transfer<Rgb565::ValueType>((Rgb565::ValueType*)(pixels), nullptr, length));
+		RF_CALL(SpiMaster::template transfer<uint16_t>((uint16_t*)(pixels), nullptr, length));
 
 		if (this->releaseMaster())
 			Cs::set();

src/modm/driver/touch/touch2046.hpp

@@ -35,7 +35,6 @@ struct touch2046 {
 		A2 = Bit6,		// see enum class ChDiff / ChSingleEnd
 		A1 = Bit5,
 		A0 = Bit4,
-		
 		MODE = Bit3,	// see enum class Mode
 		REF = Bit2,		// see enum class Reference
 
@@ -124,15 +123,7 @@ template < class SpiMaster, class Cs, Size R>
 class Touch2046 : public touch2046, public modm::SpiDevice< SpiMaster >, protected modm::NestedResumable<3>
 {
 public:
-	Touch2046() {
- 		this->attachConfigurationHandler([]() {
-			SpiMaster::setDataMode(SpiMaster::DataMode::Mode0);
-			SpiMaster::setDataOrder(SpiMaster::DataOrder::MsbFirst);
-			SpiMaster::setDataSize(SpiMaster::DataSize::Bit16);
-		});
-
-		Cs::setOutput(true);
-	}
+	Touch2046();
 
 	using Orientation = modm::graphic::Orientation;
 
@@ -185,7 +176,6 @@ class Touch2046 : public touch2046, public modm::SpiDevice< SpiMaster >, protect
 
 	static constexpr Control_t Measure = Control::START | Mode_t(Mode::Res_12Bit)
 		| Reference_t(Reference::Differential) | PowerDown_t(PowerDown::RefOff_AdcOn);
-	
 	static constexpr std::array<uint16_t, 8> bufferWrite = {
 		(Measure | ChDiff_t(ChDiff::Z1)).value,
 		((Measure | ChDiff_t(ChDiff::Z2)) & ~PowerDown_t::mask()).value,

src/modm/driver/touch/touch2046_impl.hpp

@@ -16,6 +16,18 @@
 
 #include <modm/math/utils/endianness.hpp>
 
+template<class SpiMaster, class Cs, Size R>
+modm::Touch2046<SpiMaster, Cs, R>::Touch2046()
+{
+	this->attachConfigurationHandler([]() {
+		SpiMaster::setDataMode(SpiMaster::DataMode::Mode0);
+		SpiMaster::setDataOrder(SpiMaster::DataOrder::MsbFirst);
+		SpiMaster::setDataSize(SpiMaster::DataSize::Bit16);
+	});
+
+	Cs::setOutput(true);
+}
+
 template<class SpiMaster, class Cs, Size R>
 modm::ResumableResult<void>
 modm::Touch2046<SpiMaster, Cs, R>::updateZ()

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

@@ -256,7 +256,7 @@ public:
 
 	/**
 	 * Set length of data to transfer
-	 * 
+	 *
 	 * @param lenght	range: 0-65535
 	 */
 	static void

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
-}
+}