Reusing LCD Display Panels From Old 3D Printers - 2025.11.20

#pragma once

// Library for 128x84 graphics display 
// Copyright (C) muman.ch, 2025.11.18
// 
// For details see
// https://muman.ch/muman/index.htm?muman-reusing-3d-printer-displays.htm


// Adafruit GFX font support
#include "gfxfont.h"


class Lcd12864
{
public:
	static const uint xPixels = 128;
	static const uint yPixels = 64;

	// Font sizes, set up by setFont()
	uint fontHeight;		// max. pixel height of tallest character
	uint fontAscender;		// max. pixels above the base line
	uint fontDescender;		// max. pixels below the base line

protected:
	int sckPin;		// clock, SCLK
	int datPin;		// data, SID/MOSI
	int csPin;		// chip select, active high

	// time last command was sent, microseconds
	ulong microsLastCommand;

	byte gdram[(xPixels * yPixels) / 8];	// graphics data ram image
	const GFXfont* gfxFont;					// Adafruit GFX font

public:
	bool begin(int clockPin, int dataPin, int chipSelectPin);

	//void enableGraphicsMode(bool enable);
	void clearDisplay();
	void clearGDram();
	void writeGDram();
	void writeGDramRectangle(uint x, uint y, uint width, uint height);
	void update();

	void setPixel(uint x, uint y);
	void clearPixel(uint x, uint y);
	void invertPixel(uint x, uint y);
	bool getPixel(uint x, uint y);

	void drawLine(uint x0, uint y0, uint x1, uint y1);
	void drawRectangle(uint x, uint y, uint width, uint height);
	void drawCircle(uint x0, uint y0, uint radius);
	void drawTriangle(uint x0, uint y0, uint x1, uint y1, uint x2, uint y2);

	void clearRectangle(uint x, uint y, uint width, uint height);
	void fillRectangle(uint x, uint y, uint width, uint height);
	void invertRectangle(uint x, uint y, uint width, uint height);

	void drawBitmap8(const byte* bitmap, uint x, uint y, uint width, uint height);
	void drawBitmap16(const uint16_t* bitmap, uint x, uint y, uint width, uint height);
	void drawBitmap32(const uint32_t* bitmap, uint x, uint y, uint width, uint height);

	void setFont(const GFXfont* gfxFont);
	const GFXfont* getFont() { return gfxFont; }
	uint drawChar(char ch, uint x, uint y);
	uint drawText(const char* s, uint x, uint y);
	bool getTextBounds(const char* s, uint* width, uint* height);

	uint drawCP437Char(char ch, uint x, uint y);
	uint drawCP437Text(const char* s, uint x, uint y);

protected:
	void paintRectangle(uint action, uint x, uint y, uint width, uint height);
	void writeCommand(byte cmd);
	void writeData(byte data);
	void writeByte(bool rs, byte b);
	void clockOutByte(byte b);
};


// Startup
bool Lcd12864::begin(int clockPin, int dataPin, int chipSelectPin)
{
	sckPin = clockPin;
	datPin = dataPin;
	csPin = chipSelectPin;

	microsLastCommand = 0;
	clearGDram();

	pinMode(sckPin, OUTPUT);
	digitalWrite(sckPin, 1);
	pinMode(dataPin, OUTPUT);
	digitalWrite(dataPin, 1);
	pinMode(csPin, OUTPUT);
	digitalWrite(csPin, 0);

	// min. 40ms delay after power up
	while (millis() < 40)
		;

	// note: it starts up in text mode with the 'basic' instruction set
	// but if it didn't get a reset then it may already be in graphics 
	// mode with the 'extended' command set

	// function set, 8 bit interface
	writeCommand(0x30);
	delayMicroseconds(30);		// >100us delay, 75 + 30
	writeCommand(0x30);
	delayMicroseconds(30);		// >100us delay, 75 + 30

	// display on
	writeCommand(0x0C);			// (only works in text mode)
	delayMicroseconds(30);		// >100us delay, 75 + 30

	// enable graphics mode and extended instructions
	// 76543210
	// 001d0ig0
	// d : 1 = 8-bit interface, 0 = 4-bit
	// i : 1 = extended instructions, 0 = basic instructions
	// g : 1 = graphics on, 0 = graphics off 
	writeCommand(0b00110110);

	// entry mode set, cursor moves right, address increments
	writeCommand(0x06);

	clearDisplay();

	return true;
}

// Clear the display, graphics mode only
void Lcd12864::clearDisplay()
{
	clearGDram();
	writeGDram();
}

// Clear graphics data ram
void Lcd12864::clearGDram()
{
	memset(gdram, 0, sizeof(gdram));
}

// Write the entire graphics data ram buffer to the display
// https://www.handsontec.com/dataspecs/display/12864-Graphic%20LCD.pdf#page=9
void Lcd12864::writeGDram()
{
	writeGDramRectangle(0, 0, xPixels, yPixels);
}

// Update a rectangular part of the display
// note that we must write 16-bit values into GDram (graphics data ram)
void Lcd12864::writeGDramRectangle(uint x0, uint y0, uint width, uint height)
{
	uint firstWord = x0 >> 4;
	uint lastWord = firstWord + (width >> 4);
	if (lastWord == 8)
		lastWord = 7;

	uint lasty = y0 + height + 1;
	if (lasty > yPixels)
		lasty = yPixels;

	// two banks of 32 rows of 8 x 16-bit data values
	for (int y = y0; y < lasty; ++y) {

		// set GDram address for start of row
		// vertical axis y first
		uint ycmd, xcmd;
		if (y < 32) {
			// upper bank
			ycmd = 0x80 + y;		// y = 0..31
			xcmd = 0x80;			// x = 0
		}
		else {
			// lower bank
			ycmd = 0x80 + (y - 32);	// y = 0..31
			xcmd = 0x88;			// x = 8
		}
		xcmd += firstWord;

		writeCommand(ycmd);
		writeCommand(xcmd);

		// write 8 x 16-bit values
		// GDram address auto-increments
		byte* ptr = gdram + (y << 4);	// 16 bytes per row
		ptr += firstWord << 1;
		for (uint x = firstWord; x <= lastWord; ++x) {
			writeData(*ptr++);			// write 16 bits
			writeData(*ptr++);
		}
	}
}

/* for a better ST7920 board...
void ST7920LcdDriver::writeGDram()
{
	byte* ptr = gdram;

	// 64 rows of 16 x 16-bit data values
	for (int y = 0; y < 64; ++y) {

		// set DDRAM address for the row 'y', column 'x' := 0 
		// (column 'x' auto-increments for each write)
		writeCommand(0x80 + y);		// vertical first
		writeCommand(0x80);			// then horizontal

		// write 16 x 16 bit values
		// GDram address auto-increments
		for (int x = 0; x < 16; ++x) {
			writeData(*(ptr + 1));	// ms byte first
			writeData(*ptr);		// ls byte
			ptr += 2;
		}
	}
}
*/

// Refresh only the parts of the display that have been modified
void Lcd12864::update()
{
	//TODO

}

// Pixel operations

void Lcd12864::setPixel(uint x, uint y)
{
	// ignore if outside display area
	if (x >= xPixels || y >= yPixels)
		return;

	// 16 bytes per row, 8 bits per byte
	byte* ptr = gdram + (y << 4) + (x >> 3);	// (y * 16) + (x / 8);
	uint bit = 0x80 >> (x & 7);

	*ptr |= bit;

	//TODO 'dirty' rectangle
	// 'update' rectangle
}

void Lcd12864::clearPixel(uint x, uint y)
{
	// ignore if outside display area
	if (x >= xPixels || y >= yPixels)
		return;

	// 16 bytes per row, 8 bits per byte
	byte* ptr = gdram + (y << 4) + (x >> 3);	// (y * 16) + (x / 8)
	uint bit = 0x80 >> (x & 7);

	*ptr &= ~bit;

	//TODO 'dirty' rectangle
}

void Lcd12864::invertPixel(uint x, uint y)
{
	// ignore if outside display area
	if (x >= xPixels || y >= yPixels)
		return;

	// 16 bytes per row, 8 bits per byte
	byte* ptr = gdram + (y << 4) + (x >> 3);	// (y * 16) + (x / 8)
	uint bit = 0x80 >> (x & 7);

	uint bits = *ptr;
	if (bits & bit)
		bits &= ~bit;
	else
		bits |= bit;
	*ptr = (byte)bits;

	//TODO 'dirty' rectangle
}

bool Lcd12864::getPixel(uint x, uint y)
{
	if (x >= xPixels || y >= yPixels)
		return false;

	byte* ptr = gdram + (y << 4) + (x >> 3);	// (y * 16) + (x / 8)
	uint bit = 0x80 >> (x & 7);

	return (*ptr & bit) != 0;
}


// Drawing operations

void Lcd12864::drawLine(uint x0, uint y0, uint x1, uint y1)
{
	int dx = (x1 >= x0) ? x1 - x0 : x0 - x1;
	int dy = (y1 >= y0) ? y1 - y0 : y0 - y1;
	int sx = (x0 < x1) ? 1 : -1;
	int sy = (y0 < y1) ? 1 : -1;
	int err = dx - dy;

	while(1) {
		setPixel(x0, y0);

		if (x0 == x1 && y0 == y1) 
			break;
		int e2 = err + err;
		if (e2 > -dy) {
			err -= dy;
			x0 += sx;
		}
		if (e2 < dx) {
			err += dx;
			y0 += sy;
		}
	}
}

void Lcd12864::drawCircle(uint x0, uint y0, uint radius)
{
	int f = 1 - (int)radius;
	int ddx = 1;
	int ddy = -2 * (int)radius;
	int x = 0;
	int y = radius;

	setPixel(x0, y0 + radius);
	setPixel(x0, y0 - radius);
	setPixel(x0 + radius, y0);
	setPixel(x0 - radius, y0);

	while (x < y) {
		if (f >= 0) {
			y--;
			ddy += 2;
			f += ddy;
		}
		x++;
		ddx += 2;
		f += ddx;
		setPixel(x0 + x, y0 + y);
		setPixel(x0 - x, y0 + y);
		setPixel(x0 + x, y0 - y);
		setPixel(x0 - x, y0 - y);
		setPixel(x0 + y, y0 + x);
		setPixel(x0 - y, y0 + x);
		setPixel(x0 + y, y0 - x);
		setPixel(x0 - y, y0 - x);
	}
}

void Lcd12864::drawRectangle(uint x, uint y, uint width, uint height)
{
	drawLine(x, y, x + width, y);					// top
	drawLine(x, y + height, x + width, y + height);	// bottom
	drawLine(x, y, x, y + height);					// left
	drawLine(x + width, y, x + width, y + height);	// right
}

void Lcd12864::drawTriangle(uint x0, uint y0, uint x1, uint y1, uint x2, uint y2)
{
	drawLine(x0, y0, x1, y1);
	drawLine(x1, y1, x2, y2);
	drawLine(x2, y2, x0, y0);
}

void Lcd12864::fillRectangle(uint x, uint y, uint width, uint height)
{
	paintRectangle(0, x, y, width, height);
}

void Lcd12864::clearRectangle(uint x, uint y, uint width, uint height)
{
	paintRectangle(1, x, y, width, height);
}

void Lcd12864::invertRectangle(uint x, uint y, uint width, uint height)
{
	paintRectangle(2, x, y, width, height);
}


// Bitmap operations
//TODO optimize the bitmap code, it's all very similar...

// Draw a 1..8-bit width bitmap from an 8-bit byte array
void Lcd12864::drawBitmap8(const byte* bitmap, uint x, uint y, uint width, uint height)
{
	if (x >= xPixels || y >= yPixels || width == 0 || width > 8)
		return;
	if (x + width >= xPixels)
		width = xPixels - x;
	if (y + height >= yPixels)
		height = yPixels - y;
	uint startxpos = x + width - 1;

	for (uint iy = 0; iy < height; ++iy) {
		uint ypos = y + iy;
		uint xpos = startxpos;
		// set/clear pixels, bits width-1 .. 0 
		uint b = *bitmap++;		//<<<<<<<<<<<
		uint mask = 1;			//<<<<<<<<<<<
		for (uint ix = 0; ix < width; ++ix) {
			if (b & mask)
				setPixel(xpos, ypos);
			else
				clearPixel(xpos, ypos);
			--xpos;
			mask <<= 1;
		} 
	}
}

// Draw a 9..16-bit width bitmap from a 16-bit ushort array
void Lcd12864::drawBitmap16(const uint16_t* bitmap, uint x, uint y, uint width, uint height)
{
	if (x >= xPixels || y >= yPixels || width == 0 || width > 16)
		return;
	if (x + width >= xPixels)
		width = xPixels - x;
	if (y + height >= yPixels)
		height = yPixels - y;
	uint startxpos = x + width - 1;

	for (uint iy = 0; iy < height; ++iy) {
		uint ypos = y + iy;
		uint xpos = startxpos;
		// set/clear pixels, bits width-1 .. 0 
		uint w = *bitmap++;		//<<<<<<<<<
		uint mask = 1;			//<<<<<<<<<
		for (uint ix = 0; ix < width; ++ix) {
			if (w & mask)
				setPixel(xpos, ypos);
			else
				clearPixel(xpos, ypos);
			--xpos;
			mask <<= 1;
		}
	}
}

// Draw a 17..32-bit width bitmap from a 32-bit ulong array
void Lcd12864::drawBitmap32(const uint32_t* bitmap, uint x, uint y, uint width, uint height)
{
	if (x >= xPixels || y >= yPixels || width == 0 || width > 32)
		return;
	if (x + width >= xPixels)
		width = xPixels - x;
	if (y + height >= yPixels)
		height = yPixels - y;
	uint startxpos = x + width - 1;

	for (uint iy = 0; iy < height; ++iy) {
		uint ypos = y + iy;
		uint xpos = startxpos;
		// set/clear pixels, bits width-1 .. 0 
		uint32_t w = *bitmap++;		//<<<<<<<<<<
		uint32_t mask = 1;			//<<<<<<<<<<
		for (uint ix = 0; ix < width; ++ix) {
			if (w & mask)
				setPixel(xpos, ypos);
			else
				clearPixel(xpos, ypos);
			--xpos;
			mask <<= 1;
		}
	}
}


// Text operations using Adafruit GFX Library Fonts
// 
// #include the Adafruit GFX font file, then call setFont(GFXFont* gfxFont);
// create new font files with fontconverter.exe
// 
// NOTE! The 'y' position is the 'cursor position' - the bas line of the
// font character.
// 
// The font's 'yAdvance' value (the y offset between each line) is often
// too big. The lines are spaced quite far apart. This can be reduced to
// get more lines on the display, e.g. 5 instead of 4. But there's no 
// universal way to do this - you'll need to set the 'yAdvance' and 
// initial 'y' cursor position according to the font size.
// 
// Line feed '\n' and carriage return '\r' are NOT handled. These are 
// handled as drawable characters in Graphics mode. Use the x and y 
// parameters to control the text position.

// Calculates some properties of the font
void Lcd12864::setFont(const GFXfont* gfxFont) 
{
	this->gfxFont = gfxFont; 
	int numChars = gfxFont->last - gfxFont->first + 1;

	int height = 0;
	int descender = 0;
	for (int i = 0; i < numChars; ++i) {
		GFXglyph* glyph = gfxFont->glyph + i;
		if (glyph->height > height)
			height = glyph->height;
		int d = glyph->height + glyph->yOffset;
		if (d > descender)
			descender = d;
	}
	fontHeight = height;
	fontDescender = descender;
	fontAscender = height - descender + 1;
}

// writeChar() inverts the character bits,
// it assumes an all-white or all-blue background
uint Lcd12864::drawChar(char ch, uint x, uint y)
{
	if (gfxFont == NULL) {
		return 0;
	}
	if (ch < gfxFont->first || ch > gfxFont->last) {
		return 0;
	}
	GFXglyph* glyph = gfxFont->glyph + (ch - gfxFont->first);
	byte* bitmap = gfxFont->bitmap + glyph->bitmapOffset;
	uint width = glyph->width;
	uint height = glyph->height;
	x += glyph->xOffset;
	y += glyph->yOffset;

	uint bit = 0;
	uint bits = 0;
	for (uint yy = 0; yy < height; yy++) {
		for (uint xx = 0; xx < width; xx++) {
			if (!(bit & 7))
				bits = *bitmap++;
			if (bits & 0x80) {
				//see comment above
				//setPixel(x + xx, y + yy);
				invertPixel(x + xx, y + yy);
			}
			++bit;
			bits <<= 1;
		}
	}
	return glyph->xAdvance;
}

uint Lcd12864::drawText(const char* s, uint x, uint y)
{
	while (*s) {
		uint dx = drawChar(*s++, x, y);
		x += dx;
		if (x >= xPixels)
			break;
	}
	return x;
}

// Gets size of the text according to the current font
// Returns false if setFont() not called or the text contains 
// characters not in the font
bool Lcd12864::getTextBounds(const char* s, uint* width, uint* height)
{
	*width = 0;
	*height = 0;
	// must call setFont()
	if (gfxFont == NULL)
		return false;
	uint w = 0;
	while (*s) {
		char ch = *s++;
		if (ch < gfxFont->first || ch > gfxFont->last)
			return false;		// character not in the font
		GFXglyph* glyph = gfxFont->glyph + (ch - gfxFont->first);
		w += glyph->xAdvance;
	}
	*width = w;
	*height = fontHeight;
	return true;
}


#ifdef LCD12864_CP437

// Classic "Code Page 437" 5 x 8 font
// character spacing 6 pixels, line spacing 8 pixels
// for line drawing characters 179..218 use 5 pixel character spacing
// https://en.wikipedia.org/wiki/Code_page_437

#include "fontCP437.h"

uint Lcd12864::drawCP437Char(char ch, uint x, uint y)
{
	const byte* pfont = fontCP437 + ch * 5;

	// 5 x 8 bitmap
	for (uint i = 0; i < 5; ++i) {
		uint bits = *pfont++;
		for (uint j = 0; j < 8; ++j) {
			if (bits & 1)
				//setPixel(x + i, y + j);
				invertPixel(x + i, y + j);
			bits >>= 1;
		}
	}
	return 6;
}

uint Lcd12864::drawCP437Text(const char* s, uint x, uint y)
{
	while (*s) {
		x += drawCP437Char(*s++, x, y);
		if (x >= xPixels)
			break;
	}
	return x;
}

#endif


// Internal Methods

// Fill, clear or invert a rectangle
// action : 0 = fill, 1 = clear, 2 = invert
void Lcd12864::paintRectangle(uint action, uint x, uint y, uint width, uint height)
{
	if (x >= xPixels || y >= yPixels || width == 0)
		return;
	if (x + width >= xPixels)
		width = xPixels - x;
	if (y + height >= yPixels)
		height = yPixels - y;

	for (uint iy = 0; iy < height; ++iy) {
		uint y0 = y + iy;
		for (uint ix = 0; ix < width; ++ix) {
			uint x0 = x + ix;
			switch (action) {
			case 0:
				setPixel(x0, y0);
				break;
			case 1:
				clearPixel(x0, y0);
				break;
			case 2:
				invertPixel(x0, y0);
				break;
			}
		}
	}
}

void Lcd12864::writeCommand(byte cmd)
{
	// must be min. 72us between commands, use 75us to be safe
	ulong t;
	while (1) {
		t = micros();
		ulong elapsed = t - microsLastCommand;
		if (elapsed >= 75)
			break;
		yield();
	}
	microsLastCommand = t;

	writeByte(false, cmd);
}

void Lcd12864::writeData(byte data)
{
	writeByte(true, data);
}


//TODO these could be made faster by using a fast version of digitalWrite()

// Write a command or data byte
// rs : low = command, high = data
void Lcd12864::writeByte(bool rs, byte b)
{
	digitalWrite(csPin, 1);			// chip select high
	byte sync = rs ? 0xFA : 0xF8;	// sync + RW + RS, 0b11111ws0
	clockOutByte(sync);				
	clockOutByte(b & 0xF0);			// ms nibble
	clockOutByte(b << 4);			// ls nibble
	digitalWrite(csPin, 0);			// chip select low
}

// Clock out a single byte, ms bit first (bitbang)
void Lcd12864::clockOutByte(byte b)
{
	for (int i = 0; i < 8; ++i) {
		digitalWrite(datPin, b & 0x80 ? 1 : 0);
		digitalWrite(sckPin, 0);
		digitalWrite(sckPin, 1);
		b <<= 1;
	}
}

#pragma once

// LCD character display driver with PCF8754 I2C interface
// Copyright (C) muman.ch, 2025.11.15
// info@muman.ch
// https://muman.ch/muman/index.htm?muman-reusing-3d-printer-displays.htm

#include <Wire.h>

#ifdef DEBUG
#define I2C_ASSERT(b) if (!(b)) { Serial.println("ASSERT Failed!"); }
#else
#define I2C_ASSERT(b)
#endif


class LcdDisplayI2C 
{
	// Control bits, usually bits 0..3, see I2C adapter circuit diagram
	enum CTRL {
		NONE = 0,
		RS = 0x01,		// P4 RS  Register select: 0=Instruction register (for write),
						//        Busy register(for read); 1=Data register(for read and write)
		RW = 0x02,		// P5 RW  Read/Write: 0=Write mode; 1=Read mode
		EN = 0x04,		// P6 EN  Enable
		BL = 0x08		// P7 BL  Backlight: 1=on; 0=off (also controlled by jumper)
	};

	// Saved values for Display on/off control command, D C B bits
	// all three bits are written by the command, so we must keep track of the current values
	enum DISP {
		DISPON = 0x04,	// D display on/off
		CURSOR = 0x02,	// C cursor on/off
		BLINK = 0x01	// B cursor blink on/off
	};

	TwoWire* wire;
	int i2cAdds;		// I2C slave address
	int rows;			// 1, 2, 4
	int columns;		// 8, 16, 20, 40
	CTRL backlight;		// bit P3 is the backlight, this holds the P3 value
	DISP dispCtrl;		// current value of LCD's display control register
	int* rowOffset;		// address offsets to the start of each LCD line (DDRAM memory addresses)

public:
	enum ENTRYMODE {
		SH = 0x01,		// display shift: 0=not shifted; 1=display shifted (ID 1=shift left, ID 0=shift right)
		ID = 0x02		// cursor movement (DDRAM and CGRAM address): 1=increment; 0=decrement
	};

	bool begin(TwoWire* twoWire, int i2cAddress, int rows, int columns);
	void backlightOn(bool backlightOn);
	void clearDisplay();
	void displayOn(bool displayOn);
	void cursorUnderline(bool show);
	void cursorBlink(bool show);
	void cursorHome();
	void cursorPos(int row, int column);
	void entryModeSet(ENTRYMODE mode);
	void putChar(char ch, int row, int column);
	void putString(const char* s, int row, int column);
	void putChar(char ch);
	void putString(const char* s);
	//void putLines(char* lines[]);
	void writeCGRAM(int charIndex, byte charData[8]);

protected:
	bool writeCommand(int data);
	bool writeData(int data);
	bool writeByte(CTRL ctrl, int data);
	bool writeNibble(CTRL ctrl, int data);
	bool write(byte b);
	//void delayMicroseconds(uint microseconds);
};

bool LcdDisplayI2C::begin(TwoWire* twoWire, int i2cAddress, int rows, int columns)
{
	I2C_ASSERT(rows == 1 || rows == 2 || rows == 4);
	I2C_ASSERT(columns == 8 || columns == 16 || columns == 20 || columns == 40);
		
	wire = twoWire;
	i2cAdds = i2cAddress;
	this->rows = rows;
	this->columns = columns;

	// for 4-line displays, the offset for the last 2 lines depends on characters-per-line
	rowOffset = new int[4] { 0x00, 0x40, columns, 0x40 + columns };

	// the lcd starts in 8-bit mode
	// send several "set 4-bit mode" commands (0x03) with mysterious delays in between
	// see LCD documentation
	// function set: RS=0; RW=0; 4-bit data=0011
	writeNibble(CTRL::NONE, 0);
	delay(40);
	writeNibble(CTRL::NONE, 0x03);
	delay(5);
	writeNibble(CTRL::NONE, 0x03);
	delay(5);
	writeNibble(CTRL::NONE, 0x03);
	delay(5);

	// set 4-bit mode
	writeNibble(CTRL::NONE, 0x02);
	delay(1);

	// Funtion Set
	// configure the LCD for number of lines and font size
	// this cannot be changed later
	// command = 001dnf00
	// d : 1=8-bit, 0=4-bit data
	// n : 1=2 lines, 0=1 lines
	// f : font size 1=5x11, 0=5x8
	// for example:
	// n f   lines   size
	// 0 0   1       5x8
	// 0 1   1       5x11
	// 1 x   2       5x8    <- we use this one
	if (!writeCommand(0x28))
		return false;			// lcd not present or not responding

	// Entry Mode Set
	// address increments, cursor moves right
	entryModeSet(ENTRYMODE::ID);

	// set defaults, LCD has no hardware reset
	displayOn(true);
	clearDisplay();
	cursorHome();
	cursorBlink(false);
	cursorUnderline(false);
	backlightOn(true);

	return true;
}

// Note: You can't see the display when the backlight is off!
// but this could be used to flash the display
// the backlight on my module draws 10mA
void LcdDisplayI2C::backlightOn(bool backlightOn)
{
	// save the bit state, it's written on every command (PCF8574 output P3)
	backlight = backlightOn ? CTRL::BL : CTRL::NONE;

	// just set/clear the bit
	write((byte)backlight);
}

// Clears the display by filling it with spaces
// the cursor position remains unchanged
void LcdDisplayI2C::clearDisplay()
{
	writeCommand(0x01);

	// command takes 1.53ms
	// use delay() because we can't poll the BUSY flag BF
	delay(2);
}

// All characters are hidden when the display is off, but nothing else is changed
// this can be used to flash the text on the display
void LcdDisplayI2C::displayOn(bool displayOn)
{
	int ctrl = dispCtrl;
	if (displayOn)
		ctrl |= DISP::DISPON;
	else
		ctrl &= ~DISP::DISPON;

	// save the bit state, it's written on every command
	dispCtrl = (DISP)ctrl;

	writeCommand(0x08 | ctrl);
}

// Show or hide the static underline cursor '_'
void LcdDisplayI2C::cursorUnderline(bool show)
{
	int ctrl = dispCtrl;
	if (show)
		ctrl |= DISP::CURSOR;
	else
		ctrl &= ~DISP::CURSOR;
	dispCtrl = (DISP)ctrl;

	writeCommand(0x08 | ctrl);
}

// Show or hide the blinking box cursor '█'
void LcdDisplayI2C::cursorBlink(bool show)
{
	int ctrl = (int)dispCtrl;
	if (show)
		ctrl |= DISP::BLINK;
	else
		ctrl &= ~DISP::BLINK;
	dispCtrl = (DISP)ctrl;

	writeCommand(0x08 | ctrl);
}

// Move cursor to 0, 0
void LcdDisplayI2C::cursorHome()
{
	writeCommand(0x02);
	// command takes 1.53ms
	delay(2);
}

void LcdDisplayI2C::cursorPos(int row, int column)
{
	I2C_ASSERT((uint)row < rows && (uint)column < columns);
	writeCommand(0x80 | (rowOffset[row] + column));
}

// Entry Mode Set, sets display shift and cursor movement direction 
// ENTRYMODE.SH : Bit 0 : Display shift: 0=not shifted; 1=display shifted
//                SH=1: ID=1 shift left, ID=0 shift right
// ENTRYMODE.ID : Bit 1 : Cursor movement (DDRAM and CGRAM address):
//                1=increment; 0=decrement
// Note: "Shift mode" means that BOTH lines are shifted, which is probably
// not what you want! I can't think of any use for this strange feature.
// You can do something far better just by re-writing the entire line with
// putString() or putLines().
void LcdDisplayI2C::entryModeSet(ENTRYMODE mode)
{
	I2C_ASSERT(((int)mode & 0xfc) == 0);
	// command = 000001is
	writeCommand(0x04 | (int)mode);
}

// Writes a single character to the given cursor location
// and moves the cursor to the next position
// does not wrap at end of line
void LcdDisplayI2C::putChar(char ch, int row, int column)
{
	cursorPos(row, column);
	writeData(ch);
}

// Writes a string at the given location
// and moves the cursor the next position
void LcdDisplayI2C::putString(const char* s, int row, int column)
{
	cursorPos(row, column);
	putString(s);
}

// Writes a single character to the current cursor location
// and moves the cursor to the next position
void LcdDisplayI2C::putChar(char ch)
{
	writeData(ch);
}

// Writes a string at the current cursor location
// and moves the cursor to the next position
void LcdDisplayI2C::putString(const char* s)
{
	for (int i = 0; s[i] != 0; i++) {
		writeData(s[i]);
	}
}

/*
// Writes the entire display in one shot
// lines[] array lengths must match the display rows/columns
// the final cursor position is one character beyond the end of the display
void LcdDisplayI2C::putLines(char* lines[])
{
	int row = 0;
	foreach(char* s in lines) {
		I2C_ASSERT(s.Length == columns);
		cursorPos(row++, 0);
		putString(s);
	}

}
*/

// Write programmable character in "character generater RAM" (CGRAM)
// character is assumed to be 5x8: 5-bit data width (0x00..0x1f) x 8 rows
// NOTE: After calling this, you must set the cursor position (DDRAM address)
void LcdDisplayI2C::writeCGRAM(int charIndex, byte charData[8])
{
	//TODO check this, 8 rows per character? max. 8 or 16 characters? 5 bits per row?

	// set CGRAM address
	writeCommand(0x40 | (charIndex * 8));

	// write the bitmap, 8 x 5-bit values
	for (int i = 0; i < 8; ++i) {
		writeData(charData[i] & 0x1f);
	}
}

// Internal methods
// "There is madness in his methods" - Liamwil Peareshakes

// Write a command (instruction), RS=0, RW=0
// data = 8-bits, sent as two nibbles, ms-nibble first
bool LcdDisplayI2C::writeCommand(int data)
{
	return writeByte(CTRL::NONE, data);
}

bool LcdDisplayI2C::writeData(int data)
{
	return writeByte(CTRL::RS, data);
}

bool LcdDisplayI2C::writeByte(CTRL ctrl, int data)
{
	return writeNibble(ctrl, data >> 4) && writeNibble(ctrl, data);
}

// Writes 4 bits of data and the control bits (BL RW RS),
// toggles the EN bit and handles the timing.
// The LCD runs in 4-bit mode. To write a byte, this method is called
// twice, first for the MS nibble and again for the LS nibble.
bool LcdDisplayI2C::writeNibble(CTRL ctrl, int data)
{
	// get data in bits 7..4
	data = (data << 4) & 0xf0;

	// merge in the backlight and ctrl values
	int txbyte = (int)backlight | (int)ctrl | data;

	// set up the data, EN=0
	if (!write((byte)txbyte))
		return false;
	delayMicroseconds(1);

	// set EN
	if (!write((byte)(txbyte | (int)CTRL::EN)))
		return false;
	delayMicroseconds(1);

	// clear EN
	if (!write((byte)txbyte))
		return false;

	// >37us settling time
	delayMicroseconds(40);

	return true;
}

// Returns false if failed (LCD not present, no response, ...)
bool LcdDisplayI2C::write(byte b)
{
	wire->beginTransmission(i2cAdds);
	wire->write(b);
	return wire->endTransmission() == 0;
}

/*
// Delay the given number of microseconds
void LcdDisplayI2C::delayMicroseconds(uint microseconds)
{
	unsigned long t = micros();
	while ((micros() - t) < microseconds) {
		yield();
	}
}
*/

#pragma once

// Rotary encoder
// (on 12866ZW-10 display from old Creality CR-10 V3 printer
// with Creality 3D V2.5.2 mother board)
// Copyright (C) matt@muman.ch, 2025.03.19

/*
This should work for all rotary encoders, with optional push-button.

NOTES
=====
Double-click, long-push and hold-down actions of the push-button 
are not implemented because these actions are not "intuitive". 
(If you haven't read the 2000 page manual then you won't know about 
these non-standard actions. User interfaces should be standard, 
obvious and very easy to use.)

// Rotary encoder, on LCD display panel
#define BTN_ENC  D6
#define BTN_EN1  D7
#define BTN_EN2  D8

On the Creality board, the ENC signals cannot generate interrupts, 
so they must be polled from loop() or by a timer interrupt (say) 
every 10ms. 

Only call getState() when a menu is active. There is no need to poll 
the encoder if it's not active.


POLLED EXAMPLE
==============

#include "RotaryEncoder.h"
RotaryEncoder encoder(BTN_EN1, BTN_EN2, BTN_ENC);

void loop()
{
	...
	if (menuActive) {
		long encoderPosition;
		bool buttonPressed;
		bool encoderPositionChanged = encoder.getState(&encoderPosition, &buttonPressed);

		if (encoderPositionChanged) {
			Serial.println(encoderPosition);
			...
		}
		if (buttonPressed) {
			Serial.println("button pressed");
			...
		}
	}
	...
}


TIMER INTERRUPT EXAMPLE
=======================

//https://github.com/Naguissa/uTimerLib
#include <uTimerLib.h>

#include "RotaryEncoder.h"
RotaryEncoder encoder(BTN_EN1, BTN_EN2, BTN_ENC);

void timerInterrupt()
{
	encoder.timerInterrupt();	
}

void setup()
{
	...
	// start the timer interrupt for checking the encoder every 500uS
	//TODO in practice, only enable the interrupt when the menu is active
	TimerLib.setInterval_us(timerInterrupt, 500);
}

void loop()
{
	//TODO enable the timer interrupt only when the menu is active

	if (menuActive) {
		long encoderPosition;
		bool buttonPressed;
		bool encoderPositionChanged = encoder.getStateTimer(&encoderPosition, &buttonPressed);

		if (encoderPositionChanged) {
			Serial.println(encoderPosition);
			...
		}
		if (buttonPressed) {
			Serial.println("button pressed");
			...
		}
	}
}

For reference, the Marlin code for the encoder is here:
https://github.com/MarlinFirmware/Marlin/blob/bugfix-2.1.x/Marlin/src/lcd/e3v2/common/encoder.cpp
https://github.com/MarlinFirmware/Marlin/blob/bugfix-2.1.x/Marlin/src/lcd/marlinui.cpp#L1434
See encoderReceiveAnalyze() and get_encoder_delta(). 
*/

class RotaryEncoder
{
private:
	int buttonPin, enc1pin, enc2pin;

	// for encoder position
	long count = 0;
	long lastPosition = 0;
	int lastState = 0;

	// for button debouncing
	bool lastButtonState = false;
	bool latchedState = false;
	int debounceCounter = 0;

	// for timer interrupt
	long timerEncoderPos;
	bool timerEncoderPosChanged;
	bool timerButtonPressed;

	// Table for Gray code decoding
	const int8_t decodeTable[16] = 
	{
		0, -1,  1,  0,
		1,  0,  0, -1,
		-1, 0,  0,  1,
		0,  1, -1,  0
	};

public:
	// Number of calls for the push-button debounce delay
	// this depends on speed of getState() calls and the quality of the push-button
	// e.g. if called every 1ms, a count of 10 gives a 10ms debounce delay
	const int debounceCount = 10;

	RotaryEncoder(int pinEnc1, int pinEnc2, int pinButton = 0);
	bool getState(long* position, bool* buttonPressed);
	void reset();

	void timerInterrupt();
	bool getStateTimer(long* position, bool* buttonPressed);
};

/// Constructor
RotaryEncoder::RotaryEncoder(int pinEnc1, int pinEnc2, int pinButton)
{
	enc1pin = pinEnc1;
	enc2pin = pinEnc2;
	buttonPin = pinButton;
	pinMode(pinEnc1, INPUT_PULLUP);
	pinMode(pinEnc2, INPUT_PULLUP);
	if (pinButton > 0)
		pinMode(pinButton, INPUT_PULLUP);
}

void RotaryEncoder::reset() 
{ 
	noInterrupts();
	lastPosition = 0; 
	count = 0; 
	interrupts();
}


/// For timer handling, call timerInterrupt() from a (say) 10ms timer interrupt 
/// then call getStateTimer() regularly from a loop. When using the timer, the 
/// states are latched until read.
void RotaryEncoder::timerInterrupt()
{
	bool pressed = false;
	if (getState(&timerEncoderPos, &pressed))
		timerEncoderPosChanged = true;
	if (pressed)
		timerButtonPressed = true;
}

/// Call this to get the results from the timerInterrupt handler
/// States are latched until read.
bool RotaryEncoder::getStateTimer(long* position, bool* buttonPressed)
{
	noInterrupts();

	*position = timerEncoderPos;
	*buttonPressed = timerButtonPressed;
	bool posChanged = timerEncoderPosChanged;

	// changes are latched until they are read
	timerButtonPressed = false;
	timerEncoderPosChanged = false;

	interrupts();

	return posChanged;
}

/// If not using a timer interrupt, call this from loop() at least every 10ms.
/// It returns 'true' if the encoder position has changed, so you don't have 
/// to check for changes yourself. 
/// It also detects the debounced push-button presses. 'buttonPresssed' is set 
/// high just ONCE when the button is pressed. On subsequent calls it is low, 
/// even if the button is still depressed. See NOTE in file description.
bool RotaryEncoder::getState(long* position, bool* buttonPressed)
{
	*position = lastPosition;
	*buttonPressed = false;

	// button state, debounce is needed
	// we cannot use millis() here because this may be called from an interrupt
	// so for timing we must use a 'debounceCounter'

	// optional button state is active low, 0 = button pressed
	if (buttonPin > 0) {
		bool buttonState = !digitalRead(buttonPin);
		// button state has changed, restart the debounce counter
		if (buttonState != lastButtonState) {
			lastButtonState = buttonState;
			debounceCounter = debounceCount;
		}
		// button pressed
		if (buttonState) {
			// it has just been pressed, register it as pressed immediately
			// and start the release debounce counter
			if (!latchedState) {
				latchedState = true;
				*buttonPressed = true;
				debounceCounter = debounceCount;
			}
		}
		// button was pressed and now it's released
		// it must be released for the debounce count before registering it as released
		else if (latchedState) {
			if (debounceCounter > 0)
				--debounceCounter;
			if (debounceCounter == 0) {
				latchedState = false;
				*buttonPressed = false;
			}
		}
	}

	// encoder state
	bool en1 = digitalRead(enc1pin);
	bool en2 = digitalRead(enc2pin);

	int newState = en1 + (en2 << 1);
	if (newState == lastState)
		return false;	// encoder state unchanged

	int chg = decodeTable[newState + (lastState << 2)];
	lastState = newState;
	if (chg == 0)
		return false;
	count += chg;

	long newPosition = count >> 2;
	if (newPosition == lastPosition)
		return false;
	lastPosition = newPosition;
	*position = newPosition;

	return true;		// encoder state has changed
}

#pragma once

// A wrapper for the Arduino SD Card Library
// muman.ch, 2025.11.21
/*
For details see
https://muman.ch/muman/index.htm?muman-reusing-3d-printer-displays.htm

There's a BIG problem with SPI on the Arduino Zero - it does not use the standard
SPI pins 11/12/13, so most SPI libraries and shields do not work.
But there's a solution...  
https://muman.ch/muman/index.htm?muman-reusing-3d-printer-displays.htm#muman-spi-on-the-arduino-zero

Arduino SD card library
https://github.com/arduino-libraries/SD

The SD Library is itself a wrapper for the SDFat library by Bill Greiman
https://github.com/greiman/SdFat

// SAMD21 stuff
https://learn.adafruit.com/using-atsamd21-sercom-to-add-more-spi-i2c-serial-ports/overview

https://forum.arduino.cc/t/clear-explanation-about-how-sd-cards-works-and-how-sd-library-works/1176912/10

NOTES
The SD Card uses the hardware SPI, so it CANNOT be used at the same time as the 
ICSP Atmel-ICE.
The built-in LED is on the same output pin as the SPI SCLK signal, so you can't use 
the LED and SPI at the same time.
*/


#include <SPI.h>
#include "wiring_private.h"  // for pinPeripheral() function


//problem 'extern SDClass SD;' is publicly defined, not good for class inheritance
#include <SD.h>

// New SPI channel for the Arduino Zero
#ifdef _VARIANT_ARDUINO_ZERO_
SPIClassSAMD mySPI(&sercom1, 12, 13, 11, SPI_PAD_0_SCK_1, SERCOM_RX_PAD_3);
#endif


class SDCard : public SDClass
{
private:
	uint csPin;
	uint sdDetPin;
	
public:
	void begin(uint chipSelectPin, uint sdDetectPin = 0);
	bool begin();

	// Check the SD_DET signal, if wired
	bool cardInSlot() { return sdDetPin ? digitalRead(sdDetPin) == 0 : false; }

	bool test();
};


// Initialise SPI
void SDCard::begin(uint chipSelectPin, uint sdDetectPin)
{
	csPin = chipSelectPin;
	sdDetPin = sdDetectPin;
	if (sdDetPin) {
		// if INPUT_PULLUP is not supported, add a 10..100K pull-up resistor
		pinMode(sdDetPin, INPUT_PULLUP);
	}

#ifdef _VARIANT_ARDUINO_ZERO_
	// override SPI so we can use the standard SPI pins 11/12/13
	// (the Arduino Zero has the default SPI on the ICSP connector)
	mySPI.begin();
	SPI = mySPI;

	// assign pins 11, 12, 13 to SERCOM functionality
	pinPeripheral(11, PIO_SERCOM);
	pinPeripheral(12, PIO_SERCOM);
	pinPeripheral(13, PIO_SERCOM);
#endif
}


// Initialize the SD card
// call whenever a new card is inserted
bool SDCard::begin()
{
	return SDClass::begin(csPin);
}


// this is patched out for release version
#ifdef DEBUG

bool SDCard::test()
{
	// from examples
	// https://docs.arduino.cc/learn/programming/sd-guide/

	Sd2Card card;
	SdVolume volume;
	SdFile root;

	Serial.println("\nInitializing SD card...");

	// use the initialization code from the utility libraries
	// since we're just testing if the card is working
	if (!card.init(SPI_HALF_SPEED, csPin)) {
		Serial.println("Initialization failed. Things to check:");
		Serial.println("* Are you wearing stripey pyjamas?");
		Serial.println("* Is a card inserted?");
		Serial.println("* Did you patch out the line in Sd2card.cpp if using an Arduino Zero?");
		Serial.println("* Is your wiring correct?");
		return false;
	}
	Serial.println("Card present");

	// print the type of card
	Serial.println();
	Serial.print("Card type:         ");
	switch (card.type()) {
	case SD_CARD_TYPE_SD1:
		Serial.println("SD1");
		break;
	case SD_CARD_TYPE_SD2:
		Serial.println("SD2");
		break;
	case SD_CARD_TYPE_SDHC:
		Serial.println("SDHC");
		break;
	default:
		Serial.println("Unknown");
	}

	// try to open the 'volume'/'partition' - it should be FAT16 or FAT32
	if (!volume.init(card)) {
		Serial.println("Could not find FAT16/FAT32 partition. Is the card formatted?");
		return false;
	}
	Serial.print("Clusters:          ");
	Serial.println(volume.clusterCount());
	Serial.print("Blocks x Cluster:  ");
	Serial.println(volume.blocksPerCluster());
	Serial.print("Total Blocks:      ");
	Serial.println(volume.blocksPerCluster() * volume.clusterCount());
	Serial.println();

	// print the type and size of the first FAT-type volume
	uint32_t volumesize;
	Serial.print("Volume type is:    FAT");
	Serial.println(volume.fatType(), DEC);
	volumesize = volume.blocksPerCluster();    // clusters are collections of blocks
	volumesize *= volume.clusterCount();       // we'll have a lot of clusters
	volumesize /= 2;                           // SD card blocks are always 512 bytes (2 blocks are 1KB)
	Serial.print("Volume size (KB):  ");
	Serial.println(volumesize);
	Serial.print("Volume size (MB):  ");
	volumesize /= 1024;
	Serial.println(volumesize);
	Serial.print("Volume size (GB):  ");
	Serial.println((float)volumesize / 1024.0);
	Serial.println("\nFiles found on the card (name, date and size in bytes): ");

	// SdFat library
	root.openRoot(volume);
	// list all files in the card with date and size
	root.ls(LS_R | LS_DATE | LS_SIZE);
	root.close();

	Serial.println("");
	Serial.flush();
	return true;
}

#endif

#pragma once

// Switch Debouncer
// Copyright (C) muman.ch, 2025.03.21
/*
Use this for push buttons or end-stop switches.

Microswitches must ALWAYS be debounced! Infrared speed sensors may not need it
if they use a comparator with hysterests, like an LM393.

The code registers the switch activation (closing) immediately, which is great 
for emergency switches. It is only the decativation (opening) of the switch 
that is delayed by the debounceCount.

It works with active high or active low switches, accoring to 'activeState'.
The 'debounceCount' is the number of calls for which the state must be unchanged 
before it registers as inactive. For example, if called every 2mS, use '5' for a 
10mS debounce delay.

bool getState(bool* newState) returns true if *newState has changed, false if 
unchanged, so you don't have to check for state changes yourself.
*/


/// Use this for push buttons or end-stop switches.
class DebouncedSwitch
{
private:
	int pin;
	int debCount;
	bool actState;
	
	bool firstCall;
	int debCounter;
	bool lastState;
	bool latchedState;

public:
	DebouncedSwitch(int switchPin, int debounceCount, bool activeState);
	bool getState(bool* newState);
};


// Constructicator
DebouncedSwitch::DebouncedSwitch(int switchPin, int debounceCount, bool activeState)
{
	pin = switchPin; 
	pinMode(pin, INPUT);		// or INPUT_PULLUP to save a resistor
	debCount = debounceCount; 
	actState = activeState;
	firstCall = true;
	lastState = false;
	latchedState = false;
}

/// Returns true if *newState has changed, false if unchanged
bool DebouncedSwitch::getState(bool* newState)
{
	*newState = lastState;

	bool state = digitalRead(pin);
	if (!actState)				// active low
		state = !state;

	// register current state on first call
	if (firstCall) {
		firstCall = false;
		lastState = !state;
		latchedState = lastState;
	}

	// state has changed
	if (state != lastState) {
		// restart the debounce counter
		debCounter = debCount;
		lastState = state;
	}

	// switch closed
	if (state) {
		// if it has just been closed, register it as closed immediately
		// and start the release debounce counter
		if (!latchedState) {
			latchedState = true;
			debCounter = debCount;
			*newState = true;	// switch active
			return true;		// state has changed
		}
	}

	// switch was closed and now it's open
	// it must be open for the debounceCount before registering it as open
	else if (latchedState) {
		if (debCounter > 0)
			--debCounter;
		if (debCounter <= 0) {
			latchedState = false;
			*newState = false;	// switch inactive
			return true;		// state has changed
		}
	}
	return false;				// state unchanged
}

// 3D Printer Display Panel Demo
// for 128x64 graphics panel with rotary encoder and SD card
// muman.ch, 2025.11.22
// 
// For details see
// https://muman.ch/muman/index.htm?muman-reusing-3d-printer-displays.htm


// Libraries used
#include <SD.h>
#include <Wire.h>
#include <SPI.h>

// Enable debug features
#define DEBUG


// Digital outputs used by the panel

#define LCD_CS   2		// } software SPI for 128x64 LCD
#define LCD_SCK  3		// }
#define LCD_MOSI 4		// }
#define BEEPER   5
#define BTN_ENC  6		// Encoder Push Button
#define BTN_EN1  7		// Encoder 1
#define BTN_EN2  8		// Encoder 2

#define SD_CSEL 10		// SPI SD chip select
#define SD_DET  9		// SD detect, active low


// Example bitmaps
// (you can probably create better designs)
// using 'const' replaces PROGMEM, but maybe not on all platforms
// the bitmap max. width is 8, 16 or 32
// the height can be up to 64 rows

const byte bmp8[] = 
{
	0b00001000,
	0b00011100,
	0b00111110,
	0b01111111,
	0b00111110,
	0b00011100,
	0b00001000
};

const ushort bmp16[] =
{
	0b1000000000010010,
	0b0100000000100010,
	0b0010000001000010,
	0b0001000010000010,
	0b0000100100000010,
	0b0000011000000010,
	0b0000011000000010,
	0b0000100100000010,
	0b0001000010000010,
	0b0010000001000010,
	0b0100000000100010,
	0b1000000000010010
};

const ulong bmp32[12] =
{
//    12345678901234567890123456789012
	0b10000000000100101000000000010010,
	0b01000000001000100100000000100010,
	0b00100000010000100010000001000010,
	0b00010000100000100001000010000010,
	0b00001001000000100000100100000010,
	0b00000110000000100000011000000010,
	0b00000110000000100000011000000010,
	0b00001001000000100000100100000010,
	0b00010000100000100001000010000010,
	0b00100000010000100010000001000010,
	0b01000000001000100100000000100010,
	0b10000000000100101000000000010010
};

// An Adafruit font
// see https://github.com/adafruit/Adafruit-GFX-Library/tree/master/Fonts
#define FONT_NAME FreeSans9pt7b
#include "FreeSans9pt7b.h"

// 128x64 LCD
#define LCD12864_CP437	// enable the CP437 5x7 font 
#include "Lcd12864.h"
Lcd12864 lcd;

// SD card
#include "SDCard.h"
SDCard sdcard;

// Rotary encoder
// just to confuse you, this uses a constructor instead of begin()
#include "RotaryEncoder.h"
RotaryEncoder encoder(BTN_EN1, BTN_EN2, BTN_ENC);


void setup()
{
	// for debug output
	Serial.begin(115200);

	// the beeper is on an output, make sure it's off
	pinMode(BEEPER, OUTPUT);
	digitalWrite(BEEPER, 0);

	delay(1000);

	// configure the software SPI
	lcd.begin(LCD_SCK, LCD_MOSI, LCD_CS);

	// select the large font
	lcd.setFont(&FONT_NAME);

	// draw some shapes
	lcd.drawRectangle(0, 0, lcd.xPixels - 1, lcd.yPixels - 1);

	// add some text
	lcd.drawCP437Text("Hello, cruel world", 10, 6);

	const char* s = "Large Font";
	uint swidth, sheight;
	lcd.getTextBounds(s, &swidth, &sheight);
	uint sx = (lcd.xPixels - swidth) / 2;
	uint sy = sheight + 13;
	lcd.drawText("Large Font", sx, sy);

	// draw a bitmap
	lcd.drawBitmap32(bmp32, 8, sy + 12, 32, sizeof(bmp32) / sizeof(ulong));

	// draw a circle
	lcd.drawCircle(110, 47, 10);

	// update the display's graphics data ram
	lcd.writeGDram();


	// SD card, patch this out if the SD card is not present
	sdcard.begin(SD_CSEL, SD_DET);
	sdcard.test();
	
#if 0
	if (sdcard.begin()) {

		// SD card read file example
		// change 'this'filename' to the name of a text file on the SD card
		const char* filename = "PANGOLIN.GCO";
		int lineCounter = 100;	
		byte buf[100];
		Serial.println(filename);
		File file = sdcard.open(filename);
		while (1) {
			int n = file.readBytes(buf, sizeof(buf));
			if (n <= 0)
				break;
			for (int i = 0; i < n; ++i) {
				char ch = (char)(buf[i]);
				Serial.print(ch);
				if (ch == '\n')
					Serial.print('\r');
				if (lineCounter-- == 0)
					break;
			}
			Serial.flush();
			if (n < sizeof(buf) || lineCounter == 0)
				break;
		}
		file.close();
		Serial.println();
	}

#endif
}

long tlast = 0;
long tbutton = 0;
int lastSdDet = -1;

void loop()
{
	bool sdDet = !digitalRead(SD_DET);
	if (sdDet != lastSdDet) {
		lastSdDet = sdDet;

		//TODO SD card inserted/removed

	}

	// poll the rotary encoder every millisecond
	// steps will be missed if it's polled too slowly,
	// depending on the MCU speed and loop timing
	// normally a hardware timer should be used
	ulong tnow = micros();
	if ((tnow - tlast) >= 1000) {
		tlast = tnow;

		long position;
		bool buttonPressed;
		if (encoder.getState(&position, &buttonPressed)) {

			// display the new rotary position
			char buf[32];
			sprintf(buf, "%ld", position);

			uint width = 36;
			uint height = 8;
			uint x = lcd.xPixels / 2;
			uint y = 45;

			// clear the background before drawing the text
			lcd.clearRectangle(x, y, width, height);

			// the text is drawn by inverting the background
			lcd.drawCP437Text(buf, x, y);

			// update only the rectangle that has changed
			lcd.writeGDramRectangle(x, y, width, height);
		}

		// turn on beeper when button is pressed
		if (buttonPressed) {
			digitalWrite(BEEPER, true);
			tbutton = tnow;
		}
	}

	// turn off button pressed beeper after a few milliseconds
	if (tbutton != 0) {
		if ((tnow - tbutton) > 20000) {
			digitalWrite(BEEPER, false);
			tbutton = 0;
		}
	}
}

// 3D Printer Display Panel Demo
// for the 4x20 character display panel with rotary encoder and SD card
// muman.ch, 2025.11.19
// 
// For details see
// https://muman.ch/muman/index.htm?muman-reusing-3d-printer-displays.htm

#include <Wire.h>
#include <SPI.h>

// Enable debug features
#define DEBUG


// Digital outputs used by the panel
// remove the 'D' for Arduinos
#define BTN_ENC  D6		// Encoder Push Button
#define BTN_EN1  D7		// Encoder 1
#define BTN_EN2  D8		// Encoder 2
#define SD_CSEL  D10	// SPI SD chip select
#define SD_DET   D9		// SD detect, active low

// the beeper is connected to the backlight output
#define beeperOn backlightOn

// 4x20 character display
#include "LcdDisplayI2C.h"
LcdDisplayI2C lcd;

// SD card
#include "SDCard.h"
SDCard sdcard;

// Rotary encoder
// just to confuse you, this uses a constructor instead of begin()
#include "RotaryEncoder.h"
RotaryEncoder encoder(BTN_EN1, BTN_EN2, BTN_ENC);


// Character bitmaps 5x8 for programmable characters 0..7
// Box drawing characters

const byte ch0[8] =
{
	0b00000,
	0b00000,
	0b00000,
	0b00111,
	0b00100,
	0b00100,
	0b00100,
	0b00100
};

const byte ch1[8] =
{
	0b00000,
	0b00000,
	0b00000,
	0b11100,
	0b00100,
	0b00100,
	0b00100,
	0b00100
};

const byte ch2[8] =
{
	0b00100,
	0b00100,
	0b00100,
	0b00111,
	0b00000,
	0b00000,
	0b00000,
	0b00000
};

const byte ch3[8] =
{
	0b00100,
	0b00100,
	0b00100,
	0b11100,
	0b00000,
	0b00000,
	0b00000,
	0b00000
};

const byte ch4[8] =
{
	0b00000,
	0b00000,
	0b00000,
	0b11111,
	0b00000,
	0b00000,
	0b00000,
	0b00000
};

const byte ch5[8] =
{
	0b00100,
	0b00100,
	0b00100,
	0b00100,
	0b00100,
	0b00100,
	0b00100,
	0b00100
};

const byte ch6[8] =
{
	0b00100,
	0b00100,
	0b00100,
	0b11111,
	0b00000,
	0b00000,
	0b00000,
	0b00000
};

const byte ch7[8] =
{
	0b00000,
	0b00000,
	0b00000,
	0b11111,
	0b00100,
	0b00100,
	0b00100,
	0b00100
};


void setup()
{
	// for debug output
	Serial.begin(115200);

	// configure I2C and lcd display
	// the PCF8574 address pins A3..0 are all connected to GND, 
	// so the I2C address is 0x20
	Wire.begin();
	Wire.setClock(100000);
	Wire.setTimeout(200);
	lcd.begin(&Wire, 0x20, 4, 20);

	// the beeper is on the backlight output of the I2C I/O expander
	lcd.beeperOn(false);			// backlightOn()

	delay(1000);

	// display some texts
	lcd.putString("Hello, World", 0, 0);
	lcd.putString("Box Chars: ", 1, 0);
	lcd.putString("Encoder Pos: 0", 3, 0);

	// program the Character Generator RAM 
	// for character codes 0..7 with 5x8 bit box characters
	lcd.writeCGRam(0, ch0);
	lcd.writeCGRam(1, ch1);
	lcd.writeCGRam(2, ch2);
	lcd.writeCGRam(3, ch3);
	lcd.writeCGRam(4, ch4);
	lcd.writeCGRam(5, ch5);
	lcd.writeCGRam(6, ch6);
	lcd.writeCGRam(7, ch7);

	// display the programmed CG RAM box characters 0x00..0x07
	// NOTE: character code 0x00 can't be used with putString()
	// because 0x00 (NUL) is the string terminator character
	lcd.putChar(0x00, 1, 11);
	lcd.putString("\x01\x02\x03\x04\x05\x06\x07", 1, 12);

	// SD card test
	// patch this out if the SD card is not present
	sdcard.begin(SD_CSEL);
	pinMode(SD_DET, INPUT_PULLUP);
	
	sdcard.test();

#if 0	
	// SD card read file example
	if (sdcard.begin(SD_CSEL)) {
	
		// change 'this'filename' to the name of a text file on the SD card
		const char* filename = "PANGOLIN.GCO";

		Serial.println(filename);
		File file = sdcard.open(filename);
		while (1) {
			int n = file.readBytes(buf, sizeof(buf));
			if (n <= 0)
				break;
			for (int i = 0; i < n; ++i) {
				char ch = (char)(buf[i]);
				Serial.print(ch);
				if (ch == '\n')
					Serial.print('\r');
			}
			Serial.flush();
			if (n < sizeof(buf))
				break;
		}
		file.close();
	}
#endif
}


ulong tlast1 = 0;
ulong tlast2 = 0;
byte ch = 0;

void loop()
{

	// poll the rotary encoder every millisecond
	// steps will be missed if it's polled too slowly,
	// depending on the MCU speed and loop timing
	// normally a hardware timer should be used
	ulong tnow = micros();
	if ((tnow - tlast1) >= 1000) {
		tlast1 = tnow;

		long position;
		bool buttonPressed;
		if (encoder.getState(&position, &buttonPressed)) {
			// display the new rotary position
			char buf[32];
			sprintf(buf, "%ld   ", position);
			lcd.putString(buf, 3, 13);
		}

		if (buttonPressed) {
			//TODO button pressed (already debounced)		
		}
	}

	// display entire character set, 20 characters at a time
	// update every 2 seconds
	if ((tnow - tlast2) >= 2000000) {
		tlast2 = tnow;
		lcd.cursorPos(2, 0);
		for (int i = 0; i < 20; ++i) {
			lcd.putChar(ch++);
			if (ch == 0)
				break;
		}
	}
}