Implemented modm::accessor for any writeImage(..)

Author: TomSaw

src/modm/driver/display/ili9341.hpp

@@ -36,16 +36,17 @@ namespace modm
 {
 
 /// @ingroup modm_driver_ili9341
-template<class Interface, class Reset, size_t BC = 1024>
+template<class Interface, class Reset, size_t BC = 512>
 // requires std::derived_from<Painter, RemotePainter<R>>
 class Ili9341 : public Interface,
 	// HACK Can't inherit modm::graphic::RemotePainter using RF
 	// Waiting for fibers: https://github.com/modm-io/modm/pull/439
 	// : public RemotePainter<Resolution<320, 240>, Interface>,
-	public graphic::Display<color::Rgb565<true>, graphic::Resolution<320, 240>, true>,
-	public graphic::FlashPainter<true>
+	public graphic::Display<color::Rgb565<true>, graphic::Resolution<320, 240>, true>
 {
-	static_assert(BC >= 128, "Buffer for conversion requires a reasonable minimum size.");
+	// OPTIMIZE determine good contraints 
+	static_assert(BC >= 32, "Conversion Buffer < 64 pixels produces too much overhead.");
+	static_assert(BC <= 4096, "Conversion Buffer > 4048 pixels doesn't make it better.");
 
 	using Toggle = ili9341_register::Toggle;
 	using ReadWrite = ili9341_register::ReadWrite;
@@ -109,23 +110,46 @@ class Ili9341 : public Interface,
 	modm::ResumableResult<void>
 	writePattern(Rectangle rectangle, P pattern);
 
-	// Write equal colored BufferInterface
+	/**
+	 * Write colored Image
+	 *
+	 * @param image		Image with Flash or Ram Accessor
+	 * @param origin	Placement of the image
+	 */
+/* 	template<Color C_, template<typename> class Accessor>
 	modm::ResumableResult<void>
-	writeBuffer(const BufferInterface<C> *buffer, Point origin = {0, 0});
+	writeImage(Image<C_, Accessor> image, Point origin = {0, 0}); */
 
-	// Write different colored BufferInterface
-	template<Color C_>
+	/**
+	 * Write equal colored Image
+	 *
+	 * @param image		Image with Flash or Ram Accessor
+	 * @param origin	Placement of the image
+	 */
+	template<template<typename> class Accessor>
 	modm::ResumableResult<void>
-	writeBuffer(const BufferInterface<C_> *buffer, Point origin = {0, 0});
+	writeImage(Image<C, Accessor> image, Point origin = {0, 0});
 
-	// Write monochrome BufferInterface
+	/**
+	 * Write monochrome Image
+	 *
+	 * @param image		Image with Flash or Ram Accessor
+	 * @param origin	Placement of the image
+	 */
+	template<template<typename> class Accessor>
 	modm::ResumableResult<void>
-	writeBuffer(const BufferInterface<bool> *buffer, Point origin = {0, 0});
+	writeImage(Image<bool, Accessor> image, Point origin = {0, 0});
 
-	// Write monochrome Flash
+	template<Color C_>
 	modm::ResumableResult<void>
-	writeFlash(modm::accessor::Flash<uint8_t> data, uint16_t width, uint16_t height,
-		Point origin = {0, 0}) final;
+	writeImage(BufferInterface<C_> *buffer, Point origin = {0, 0}) {
+		RF_BEGIN();
+		RF_END_RETURN_CALL(writeImage(modm::graphic::Image<C_, modm::accessor::Ram>(buffer), origin));
+	}
+
+	// Write equal colored Image from Accessor
+	// modm::ResumableResult<void>
+	// writeImage(Image<C> image) final;
 
 	// Clear whole screen with color
 	modm::ResumableResult<void>
@@ -152,6 +176,7 @@ class Ili9341 : public Interface,
 private:
 	// Static variables for resumable functions
 	Section section;
+	Point cursor;
 	// ##################################################################
 
 protected:
@@ -194,8 +219,6 @@ class Ili9341 : public Interface,
 		// Parallel use in resumable function: don't overlap!
 		struct
 		{
-			MonochromeReader mono_reader; // Helper to read monochrome data
-
 			C buffer[BC]; // Bulk buffer
 			size_t i; // Bulk buffer index
 			Point scanner; // display index

src/modm/driver/display/ili9341_impl.hpp

@@ -236,7 +236,7 @@ modm::Ili9341<Interface, Reset, BC>::updateClipping()
 	RF_END();
 }
 
-// -- Write from Pattern ---------------------------------
+// -- Write Pattern from Generator ---------------------------
 template<class Interface, class Reset, size_t BC>
 template<ColorPattern P>
 modm::ResumableResult<void>
@@ -269,113 +269,69 @@ modm::Ili9341<Interface, Reset, BC>::writePattern(Rectangle rectangle, P pattern
 	RF_END();
 }
 
-// -- Write equal colored BufferInterface -----------------------------
+// -- Write equal colored BufferInterface --------------------
 template<class Interface, class Reset, size_t BC>
+template<template<typename> class Accessor>
 modm::ResumableResult<void>
-modm::Ili9341<Interface, Reset, BC>::writeBuffer(
-	const BufferInterface<C> *buffer, Point origin) {
+modm::Ili9341<Interface, Reset, BC>::writeImage(
+	modm::graphic::Image<C, Accessor> image, Point origin)
+{
 	RF_BEGIN();
 
-	this->layout = buffer->getLayout();
-
-	this->clipping = this->getIntersection(Rectangle(origin, this->layout.size));
+	this->clipping = this->getIntersection(Rectangle(origin, image.size));
 	RF_CALL(updateClipping());
 
 	// Add left offset
-	if(origin.x < 0)
-		this->layout.buffer += -origin.x * this->layout.size.y * 2;
+	/* if(origin.x < 0)
+		this->layout.buffer += -origin.x * this->layout.size.y * 2; */
 
-	// Check if we exceed the display vertically
-	if (origin.y < 0 or origin.y + this->layout.size.y != this->clipping.bottomRight.y)
+	// Check if display is exceeded vertically
+/*	if (origin.y < 0 or origin.y + this->layout.size.y != this->clipping.bottomRight.y)
 	{
+ 		// Can't transfer continuously, send row by row
+		
 		// Add top offset
 		if(origin.y < 0)
 			this->layout.buffer += -origin.y * 2;
 
-		// Can't transfer buffer continuously, send row by row
 		p.pixels_bulk = this->clipping.getHeight();
 		while(p.pixels) {
 			RF_CALL(this->writeData((C*)(this->layout.buffer), p.pixels_bulk));
 			this->layout.buffer += this->layout.size.y * 2;
 			p.pixels -= p.pixels_bulk;
 		}
 	} else
-	{
-		// Transfer buffer continuously in one shot
-		RF_CALL(this->writeData((C*)(this->layout.buffer), p.pixels));
-	}
-
-	RF_END();
-}
-
-// -- Write different colored BufferInterface -----------------------------
-template<class Interface, class Reset, size_t BC>
-template<Color C_>
-modm::ResumableResult<void>
-modm::Ili9341<Interface, Reset, BC>::writeBuffer(
-	const BufferInterface<C_> *buffer, Point origin) {
-	RF_BEGIN();
+	{ */
+		// Transfer buffer in one shot
+		RF_CALL(this->writeData((C*)(image.getPointer()), p.pixels));
+	/* } */
 
-	this->clipping = this->getIntersection(Rectangle(origin, this->layout.size));
-	RF_CALL(updateClipping());
-	
 	RF_END();
 }
 
 // -- Write monochrome BufferInterface -------------------
 template<class Interface, class Reset, size_t BC>
+template<template<typename> class Accessor>
 modm::ResumableResult<void>
-modm::Ili9341<Interface, Reset, BC>::writeBuffer(
-	const BufferInterface<bool> *buffer, Point origin) {
-	RF_BEGIN();
-
-	this->layout = buffer->getLayout();
-	this->clipping = this->getIntersection(Rectangle(origin, this->layout.size));
-	RF_CALL(updateClipping());
-
-	p.mono_reader = MonochromeReader(this->layout.buffer, this->layout.size.x, origin);
-	p.scanner = this->clipping.topLeft;
-
- 	while (p.pixels)
-	{
-		// Convert next Bulk
-		for(p.i = 0; p.i < std::min<uint32_t>(p.pixels, BC); p.i++) {
-			p.buffer[p.i] = p.mono_reader() ? color : C(html::Black);
-			if (++p.scanner.y == this->clipping.bottomRight.y) {
-				scannerNextRow();
-				p.mono_reader.nextRow();
-			}
-		}
-		// Transfer
-		RF_CALL(this->writeData(p.buffer, p.i));
-		p.pixels -= p.i;
-	}
-
-	RF_END();
-}
-
-// -- Write monochrome Flash -----------------------------
-template<class Interface, class Reset, size_t BC>
-modm::ResumableResult<void>
-modm::Ili9341<Interface, Reset, BC>::writeFlash(modm::accessor::Flash<uint8_t> data,
-		uint16_t width, uint16_t height, Point origin) {
+modm::Ili9341<Interface, Reset, BC>::writeImage(
+	modm::graphic::Image<bool, Accessor> image, Point origin) {
 	RF_BEGIN();
 
-	this->clipping = this->getIntersection(Rectangle(origin, {width, height}));
+	this->clipping = this->getIntersection(Rectangle(origin, image.size));
 	RF_CALL(updateClipping());
 
-	// FIXME MonochromeReader must learn to handle modm::accessor::Flash<uint8_t>
-	// p.mono_reader = MonochromeReader(data, width, origin);
+	// FIXME store image locally
+	image.initializeReader(origin);
 	p.scanner = this->clipping.topLeft;
 
  	while (p.pixels)
 	{
 		// Convert next Bulk
 		for(p.i = 0; p.i < std::min<uint32_t>(p.pixels, BC); p.i++) {
-			// p.buffer[p.i] = p.mono_reader() ? color : C(html::Black);
+			p.buffer[p.i] = image() ? color : C(html::Black);
 			if (++p.scanner.y == this->clipping.bottomRight.y) {
 				scannerNextRow();
-				// p.mono_reader.nextRow();
+				image.nextRow();
 			}
 		}
 		// Transfer
@@ -393,26 +349,23 @@ modm::Ili9341<Interface, Reset, BC>::drawFast(Point point)
 {
 	RF_BEGIN();
 	RF_CALL(setClipping(point));
-	RF_CALL(this->writeData(color));
-	RF_END();
+	RF_END_RETURN_CALL(this->writeData(color));
 }
 
 template<class Interface, class Reset, size_t BC>
 modm::ResumableResult<void>
 modm::Ili9341<Interface, Reset, BC>::drawFast(HLine hline)
 {
 	RF_BEGIN();
-	RF_CALL(drawFast(Section(hline.start, {hline.end_x, hline.start.y + 1})));
-	RF_END();
+	RF_END_RETURN_CALL(drawFast(Section(hline.start, {hline.end_x, hline.start.y + 1})));
 }
 
 template<class Interface, class Reset, size_t BC>
 modm::ResumableResult<void>
 modm::Ili9341<Interface, Reset, BC>::drawFast(VLine vline)
 {
 	RF_BEGIN();
-	RF_CALL(drawFast(Section(vline.start, {vline.start.x + 1, vline.end_y})));
-	RF_END();
+	RF_END_RETURN_CALL(drawFast(Section(vline.start, {vline.start.x + 1, vline.end_y})));
 }
 
 template<class Interface, class Reset, size_t BC>

src/modm/driver/display/sh1106.hpp

@@ -37,10 +37,19 @@ class Sh1106 : public Ssd1306<I2cMaster, H>
 
 	Sh1106(uint8_t address = 0x3C) : Ssd1306<I2cMaster, H>(address) {}
 
-	// Write monochrome BufferInterface
+	// Write monochrome Image
 	// Caution: origin.y rounds to multiples of 8
+	template<template<typename> class Accessor>
 	modm::ResumableResult<bool>
-	writeBuffer(const BufferInterface<C> *buffer, Point origin = {0, 0});
+	writeImage(Image<bool, Accessor> image, Point origin = {0, 0});
+
+	// FIXME Why is not inherited from Ssd1306?
+	template<Color C_>
+	modm::ResumableResult<bool>
+	writeImage(BufferInterface<C_> *buffer, Point origin = {0, 0}) {
+		RF_BEGIN();
+		RF_END_RETURN_CALL(writeImage(modm::graphic::Image<C_, modm::accessor::Ram>(buffer), origin));
+	}
 
 protected:
 	modm::ResumableResult<bool>

src/modm/driver/display/sh1106_impl.hpp

@@ -45,13 +45,13 @@ modm::Sh1106<I2cMaster, H>::updateClipping()
 }
 
 template<class I2cMaster, uint16_t H>
+template<template<typename> class Accessor>
 modm::ResumableResult<bool>
-modm::Sh1106<I2cMaster, H>::writeBuffer(const BufferInterface<C> *buffer, Point origin) {
+modm::Sh1106<I2cMaster, H>::writeImage(Image<bool, Accessor> image, Point origin) {
 	RF_BEGIN();
 
-	this->layout = buffer->getLayout();
 	// IMPLEMENT method with getIntersection()
-	this->clipping = Rectangle(origin, this->layout.size);
+	this->clipping = Rectangle(origin, image.size);
 
 	if (this->pointInCanvas(this->clipping.bottomRight - Point(1, 1)))
 	{
@@ -65,7 +65,7 @@ modm::Sh1106<I2cMaster, H>::writeBuffer(const BufferInterface<C> *buffer, Point
 			this->commandBuffer[2] = ssd1306::AdressingCommands::PageStartAddress | yd;
 			this->transaction_success &= RF_CALL(this->writeCommands(3));
 
-			RF_WAIT_UNTIL(this->transaction.configureDisplayWrite(this->layout.buffer + (this->clipping.getWidth() * yb++), this->clipping.getWidth()));
+			RF_WAIT_UNTIL(this->transaction.configureDisplayWrite(image.getPointer() + (this->clipping.getWidth() * yb++), this->clipping.getWidth()));
 			RF_WAIT_UNTIL(this->startTransaction());
 			RF_WAIT_WHILE(this->isTransactionRunning());
 			this->transaction_success &= this->wasTransactionSuccessful();

src/modm/driver/display/ssd1306.hpp

@@ -158,10 +158,18 @@ class Ssd1306 : public ssd1306,
 		return writeCommands(1);
 	}
 
-	// Write monochrome BufferInterface
+	// Write monochrome Image
 	// Caution: origin.y rounds to multiples of 8
+	template<template<typename> class Accessor>
 	modm::ResumableResult<bool>
-	writeBuffer(const BufferInterface<C> *buffer, Point origin = {0, 0});
+	writeImage(Image<bool, Accessor> image, Point origin = {0, 0});
+
+	template<Color C_>
+	modm::ResumableResult<bool>
+	writeImage(BufferInterface<C_> *buffer, Point origin = {0, 0}) {
+		RF_BEGIN();
+		RF_END_RETURN_CALL(writeImage(modm::graphic::Image<C_, modm::accessor::Ram>(buffer), origin));
+	}
 
 	// Clear whole screen with color
 	modm::ResumableResult<bool>

src/modm/driver/display/ssd1306_impl.hpp

@@ -167,12 +167,12 @@ modm::Ssd1306<I2cMaster, H>::updateClipping()
 #include <modm/debug/logger.hpp>
 
 template<class I2cMaster, uint16_t H>
+template<template<typename> class Accessor>
 modm::ResumableResult<bool>
-modm::Ssd1306<I2cMaster, H>::writeBuffer(const BufferInterface<bool> *buffer, Point origin) {
+modm::Ssd1306<I2cMaster, H>::writeImage(Image<bool, Accessor> image, Point origin) {
 	RF_BEGIN();
 
-	this->layout = buffer->getLayout();
-	this->clipping = Rectangle(origin, this->layout.size);
+	this->clipping = Rectangle(origin, image.size);
 
 	if(!this->pointInCanvas(this->clipping.bottomRight - Point(1, 1))) {
 		MODM_LOG_ERROR << "buffer exceeds display border in " << __FUNCTION__ << modm::endl;
@@ -182,7 +182,7 @@ modm::Ssd1306<I2cMaster, H>::writeBuffer(const BufferInterface<bool> *buffer, Po
 	RF_CALL(updateClipping());
 
 	// FIXME Integrate this->clipping results
-	RF_WAIT_UNTIL(this->transaction.configureDisplayWrite(this->layout.buffer, this->clipping->getPixels() / 8));
+	RF_WAIT_UNTIL(this->transaction.configureDisplayWrite(image.getPointer(), this->clipping.getPixels() / 8));
 
 	this->startTransaction();
 	RF_WAIT_WHILE(this->isTransactionRunning());

src/modm/ui/color/pattern.hpp

@@ -13,8 +13,7 @@
 
 #include "pattern/gradient.hpp"
 #include "pattern/interference.hpp"
-
-#include "../shape.hpp"
+#include <modm/ui/shape/point.hpp>
 
 // TODO find a good place
 template <class P>

src/modm/ui/color/pattern/gradient.hpp

@@ -16,18 +16,18 @@
 
 using namespace modm::shape;
 
-namespace modm::color
+namespace modm::color::pattern
 {
 
 template<Color C>
-class Gradient : public BicolorPattern<C>
+class Gradient : public Bicolor<C>
 {
 protected:
 	const Point direction;
 
 public:
 	constexpr Gradient(C start, C end, Point direction = {1, 0})
-		: BicolorPattern<C>(start, end), direction(direction) {}
+		: Bicolor<C>(start, end), direction(direction) {}
 
 	constexpr C
 	operator()(Point point)