Implement integer text scaling

eink.hpp

@@ -1,21 +1,35 @@
 #pragma once
 
+#include <tuple>
+#include <type_traits>
 #include <utility>
 
+#include <cstddef>
 #include <cstdint>
+#include <cstring>
 
-#include <avr/pgmspace.h>
+#include "eink_spi.hpp"
+#include "font.hpp"
+#include "otp.hpp"
 
 #include "../clock.hpp"
+#include "../flash/flash.hpp"
 #include "../io/io.hpp"
 #include "../util/util.hpp"
 
 namespace eink {
 
-template <std::uint16_t Width, std::uint16_t Height, typename Spi, io::P RstPin, io::P DcPin, io::P BusyPin>
+template <std::uint16_t Width, std::uint16_t Height, typename Spi, io::P RstPin, io::P BusyPin>
 class Eink {
 	using word_t = typename Spi::word_t;
 
+	struct original_lut_tag {
+	};
+
+	static io::Pin<RstPin> m_rst;
+	static io::Pin<BusyPin> m_busy;
+
+  public:
 	enum class Cmd : std::uint8_t {
 		DRIVER_OUTPUT_CONTROL = 0x01,
 		DEEP_SLEEP_MODE = 0x10,
@@ -26,76 +40,52 @@ class Eink {
 		DISPLAY_UPDATE_CONTROL_2 = 0x22,
 		WRITE_RAM_BLACK = 0x24,
 		WRITE_RAM_RED = 0x26,
+		READ_RAM = 0x27,
+		LOAD_OTP_TO_RAM = 0x31,
+		WRITE_LUT = 0x32,
 		BORDER_WAVEFORM_CONTROL = 0x3C,
+		READ_RAM_CHANNEL = 0x41,
 		SET_RAM_X_ADDR_POSITIONS = 0x44,
 		SET_RAM_Y_ADDR_POSITIONS = 0x45,
 		SET_RAM_X_ADDR = 0x4E,
 		SET_RAM_Y_ADDR = 0x4F,
 	};
 
-	static io::Pin<RstPin> m_rst;
-	static io::Pin<DcPin> m_dc;
-	static io::Pin<BusyPin> m_bsy;
-	static constexpr auto THREE_WIRE_SPI = (DcPin == io::P::NONE ? true : false);
-	static_assert((THREE_WIRE_SPI && sizeof(word_t) > 1) || !THREE_WIRE_SPI,
-	              "Three wire SPI requires SPI word size of at least 9 bits");
-
-	static constexpr auto BLOCK_SIZE = 5;
-
 	enum class Color : std::uint8_t {
-		BLACK = 0b00,
-		WHITE = 0b01,
-		RED = 0b10,
-		ERROR = 0b11,
+		BLACK = 0x00,
+		RED = 0x01,
+		WHITE = 0x02,
 	};
 
-	class ImageBlock {
-	  public:
-		inline Color &operator[](const std::size_t idx)
-		{
-			return data[idx];
-		}
-
-		inline const Color &operator[](const std::size_t idx) const
-		{
-			return data[idx];
-		}
-
-	  private:
-		Color data[BLOCK_SIZE];
+	enum class RamDirection : std::uint8_t {
+		DECREMENT = 0,
+		INCREMENT = 1,
+	};
+
+	enum class FastestMovingIndex : std::uint8_t {
+		X = 0,
+		Y = 1,
 	};
 
-  public:
 	static void init()
 	{
 		m_rst.dir(io::Dir::OUT);
-		m_dc.dir(io::Dir::OUT);
-		m_bsy.dir(io::Dir::IN);
+		m_busy.pullup(false);
+		m_busy.dir(io::Dir::IN);
 		Spi::init();
 
 		reset();
-
-		waitUntilIdle();
-		sendCommand(Cmd::SW_RESET);
-		waitUntilIdle();
+		softReset();
 
 		sendCommand(Cmd::DRIVER_OUTPUT_CONTROL);
 		sendData(0xC7);
 		sendData(0x00);
 		sendData(0x01);
 
-		sendCommand(Cmd::DATA_ENTRY_MODE);
-		sendData(0x02);
-
-		sendCommand(Cmd::SET_RAM_X_ADDR_POSITIONS);
-		sendData(Width / 8 - 1);
-		sendData(0x00);
-
-		sendCommand(Cmd::SET_RAM_Y_ADDR_POSITIONS);
-		sendData(0x00);
-		sendData(0x00);
-		sendData(Height - 1);
-		sendData(0x00);
+		setDataEntryMode(RamDirection::DECREMENT, RamDirection::INCREMENT, FastestMovingIndex::X);
+		setRamRange();
+		setRamXPos();
+		setRamYPos();
 
 		sendCommand(Cmd::BORDER_WAVEFORM_CONTROL);
 		sendData(0x05);
@@ -103,35 +93,34 @@ class Eink {
 		sendCommand(Cmd::READ_TEMPERATURE_SENSOR);
 		sendData(0x80);
 
-		sendCommand(Cmd::SET_RAM_X_ADDR);
-		sendData(Width / 8 - 1);
-
-		sendCommand(Cmd::SET_RAM_Y_ADDR);
-		sendData(0x00);
-		sendData(0x00);
-
 		waitUntilIdle();
 	}
 
 	static void sendCommand(const Cmd command)
 	{
-		m_dc = false;
-		spiTransfer(static_cast<word_t>(command));
+		Spi::select(true);
+		Spi::write(static_cast<word_t>(command), true);
+		Spi::select(false);
 	}
 
 	static void sendData(word_t data)
 	{
-		if constexpr (THREE_WIRE_SPI) {
-			data |= 1 << 8;
-		}
+		Spi::select(true);
+		Spi::write(data, false);
+		Spi::select(false);
+	}
 
-		m_dc = true;
-		spiTransfer(data);
+	static word_t readData()
+	{
+		Spi::select(true);
+		const auto res = Spi::read();
+		Spi::select(false);
+		return res;
 	}
 
 	static void waitUntilIdle()
 	{
-		while (m_bsy) {
+		while (m_busy) {
 			_delay_ms(100);
 		}
 	}
@@ -144,65 +133,289 @@ class Eink {
 		_delay_ms(10);
 		m_rst = true;
 		_delay_ms(200);
+		waitUntilIdle();
 	}
 
-	template <typename Image>
-	static void draw(const Image &image)
+	static void softReset()
 	{
-		constexpr auto lookup = [](std::uint8_t bits) {
-			auto block = ImageBlock{};
-			util::for_constexpr(
-			    [&](const auto idx) {
-				    block[idx.value] = static_cast<Color>(bits % 3);
-				    bits /= 3;
-			    },
-			    std::make_index_sequence<BLOCK_SIZE>{});
-			return block;
-		};
+		sendCommand(Cmd::SW_RESET);
+		waitUntilIdle();
+	}
+
+	static void update()
+	{
+		update(original_lut_tag{});
+	}
+
+	template <typename Lut = original_lut_tag>
+	static void update(const Lut &lut)
+	{
+		constexpr auto USE_ORIGINAL_LUT = std::is_same_v<Lut, original_lut_tag>;
+		if constexpr (!USE_ORIGINAL_LUT) {
+			writeLut(lut);
+		}
+
+		sendCommand(Cmd::DISPLAY_UPDATE_CONTROL_2);
+		sendData(USE_ORIGINAL_LUT ? 0xF7 : 0xC7);
+		sendCommand(Cmd::UPDATE_DISPLAY);
+		waitUntilIdle();
+	}
+
+	template <typename RleImage>
+	static void draw(const RleImage &rleImage)
+	{
+		constexpr auto sendImageChannel = [](const auto command, const auto &image) {
+			using image_t = std::remove_cvref_t<decltype(image)>;
 
-		constexpr auto sendImageChannel = [lookup](const auto command, const auto image) {
 			sendCommand(command);
-			auto buffer = std::uint8_t{0};
-			auto bufferPos = std::uint8_t{0};
-			for (auto i = std::uint16_t{0}; i < Width * Height / BLOCK_SIZE; i++) {
-				const auto block = lookup(pgm_read_byte(&image[i]));
-				for (auto p = std::uint8_t{0}; p < BLOCK_SIZE; ++p) {
-					const auto pixel = std::uint8_t{(command == Cmd::WRITE_RAM_BLACK) ? (block[p] != Color::BLACK)
-					                                                                  : (block[p] == Color::RED)};
-					buffer |= pixel << (7 - bufferPos++);
-					if (bufferPos == 8) {
-						sendData(buffer);
-						buffer = 0;
-						bufferPos = 0;
+			for (auto j = std::size_t{0}; j < std::tuple_size_v<image_t>; ++j) {
+				const auto [count, data] = flash::loadLike<RleImage>(image[j]);
+				for (auto i = std::uint16_t{0}; i < count; ++i) {
+					if (command == Cmd::WRITE_RAM_BLACK) {
+						sendData(data);
+					} else {
+						sendData(~data);
 					}
 				}
 			}
 		};
 
-		sendImageChannel(Cmd::WRITE_RAM_BLACK, image.data());
-		sendImageChannel(Cmd::WRITE_RAM_RED, image.data());
-
-		sendCommand(Cmd::DISPLAY_UPDATE_CONTROL_2);
-		sendData(0xF7);
-		sendCommand(Cmd::UPDATE_DISPLAY);
-		waitUntilIdle();
+		sendImageChannel(Cmd::WRITE_RAM_BLACK, std::get<0>(rleImage.value));
+		sendImageChannel(Cmd::WRITE_RAM_RED, std::get<1>(rleImage.value));
 	}
 
-	static void clear()
+	static void clear(const Color color = Color::WHITE)
 	{
+		constexpr auto getFillData = [](const auto &color) -> std::pair<std::uint8_t, std::uint8_t> {
+			switch (color) {
+			case Color::BLACK:
+				return {0x00, 0x00};
+			case Color::RED:
+				return {0xFF, 0xFF};
+			case Color::WHITE:
+				return {0xFF, 0x00};
+			}
+			return {0xFF, 0x00};
+		};
+
+		const auto fillData = getFillData(color);
+
 		sendCommand(Cmd::WRITE_RAM_BLACK);
 		for (auto i = std::uint16_t{0}; i < Width * Height / 8; i++) {
-			sendData(0xff);
+			sendData(fillData.first);
 		}
 		sendCommand(Cmd::WRITE_RAM_RED);
 		for (auto i = std::uint16_t{0}; i < Width * Height / 8; i++) {
+			sendData(fillData.second);
+		}
+	}
+
+	static void drawText(const std::pair<std::uint8_t, std::uint8_t> &pos, const char *text,
+	                     const Color textColor = Color::BLACK, const Color backgroundColor = Color::WHITE,
+	                     const std::uint8_t scaling = 1)
+	{
+		const auto textLength = std::strlen(text);
+
+		constexpr auto getXScreenCoordinates = [](const std::uint8_t pos) { return (Width - pos - 1) / 8; };
+		constexpr auto flipEndianness = [](const std::uint8_t value) {
+			auto flippedVal = std::uint8_t{0};
+			for (auto i = 0; i < 8; ++i) {
+				const auto oldBit = (value >> i) & 1;
+				flippedVal |= oldBit << (8 - i - 1);
+			}
+			return flippedVal;
+		};
+
+		const auto adjustColor = [&](const auto &data, const auto command) {
+			auto backgroundData = data;
+			auto outData = data & 0x00;
+
+			if (command == Cmd::WRITE_RAM_BLACK) {
+				if (backgroundColor == Color::BLACK) {
+					backgroundData = 0x00;
+				} else if (backgroundColor == Color::RED || backgroundColor == Color::WHITE) {
+					backgroundData = 0xFF;
+				}
+
+				if (textColor == Color::BLACK) {
+					outData = backgroundData & ~data;
+				} else if (textColor == Color::RED || textColor == Color::WHITE) {
+					outData = backgroundData | data;
+				}
+			} else {
+				if (backgroundColor == Color::BLACK || backgroundColor == Color::WHITE) {
+					backgroundData = 0x00;
+				} else if (backgroundColor == Color::RED) {
+					backgroundData = 0xFF;
+				}
+
+				if (textColor == Color::BLACK || textColor == Color::WHITE) {
+					outData = backgroundData & ~data;
+				} else if (textColor == Color::RED) {
+					outData = backgroundData | data;
+				}
+			}
+
+			return outData;
+		};
+
+		const auto sendChannel = [&](const auto command) {
+			for (auto i = std::size_t{0}; i < textLength; ++i) {
+				const auto posX = pos.first + i * 8 * scaling;
+				const auto screenPosX = getXScreenCoordinates(posX);
+				setRamRange({screenPosX, screenPosX - (scaling - 1)}, {pos.second, pos.second + 8 * scaling - 1});
+				setRamXPos(screenPosX);
+				setRamYPos(pos.second);
+
+				sendCommand(command);
+				for (auto j = std::uint8_t{0}; j < 8; ++j) {
+					const auto fontByte = flash::loadLike<decltype(FONT_8X8)>(FONT_8X8.value[text[i]][j]);
+					static_assert(std::is_same_v<std::remove_cvref_t<decltype(fontByte)>, std::uint8_t>);
+					const auto dataByte = adjustColor(flipEndianness(fontByte), command);
+
+					auto scaledByte = std::uint8_t{0};
+					auto bitCounter = 0;
+					for (auto sy = std::uint8_t{0}; sy < scaling; ++sy) {
+						for (auto b = std::uint8_t{0}; b < 8; ++b) {
+							const auto currentBit = dataByte >> (8 - b - 1) & 1;
+							for (auto sx = std::uint8_t{0}; sx < scaling; ++sx) {
+								scaledByte |= currentBit << (8 - bitCounter - 1);
+								if (++bitCounter == 8) {
+									sendData(scaledByte);
+									scaledByte = 0;
+									bitCounter = 0;
+								}
+							}
+						}
+					}
+				}
+			}
+		};
+
+		sendChannel(Cmd::WRITE_RAM_BLACK);
+		sendChannel(Cmd::WRITE_RAM_RED);
+
+		setRamRange();
+		setRamXPos();
+		setRamYPos();
+	}
+
+	template <typename Lut>
+	static void writeLut(const Lut &lut)
+	{
+		static_assert(sizeof(lut) == sizeof(Waveform), "Invalid LUT size");
+
+		sendCommand(Cmd::WRITE_LUT);
+		for (auto i = std::size_t{0}; i < sizeof(lut); ++i) {
+			const auto lutByte = lut[i];
+			static_assert(std::is_same_v<std::byte, std::remove_cvref_t<decltype(lutByte)>>, "Invalid LUT value type");
+			sendData(static_cast<word_t>(lutByte));
+		}
+	}
+
+	static void autoPatternFill()
+	{
+		constexpr auto RED_PATTERN_FILL_CMD = static_cast<Cmd>(0x46);
+		constexpr auto BLACK_PATTERN_FILL_CMD = static_cast<Cmd>(0x47);
+
+		constexpr auto RED_PATTERN = 0b0'001'0'001;
+		constexpr auto BLACK_PATTERN = 0b1'000'0'000;
+
+		sendCommand(RED_PATTERN_FILL_CMD);
+		sendData(RED_PATTERN);
+		waitUntilIdle();
+
+		sendCommand(BLACK_PATTERN_FILL_CMD);
+		sendData(BLACK_PATTERN);
+		waitUntilIdle();
+	}
+
+	static void setDataEntryMode(const RamDirection &xDir = RamDirection::INCREMENT,
+	                             const RamDirection &yDir = RamDirection::INCREMENT,
+	                             const FastestMovingIndex &fastestMovingIndex = FastestMovingIndex::X)
+	{
+		auto setting = static_cast<std::uint8_t>(xDir) << 0;
+		setting |= static_cast<std::uint8_t>(yDir) << 1;
+		setting |= static_cast<std::uint8_t>(fastestMovingIndex) << 2;
+
+		sendCommand(Cmd::DATA_ENTRY_MODE);
+		sendData(setting);
+	}
+
+	static void setRamRange(const std::pair<std::uint8_t, std::uint8_t> &xrange = {Width / 8 - 1, 0},
+	                        const std::pair<std::uint16_t, std::uint16_t> &yrange = {0, Height - 1})
+	{
+		sendCommand(Cmd::SET_RAM_X_ADDR_POSITIONS);
+		sendData(xrange.first & 0b00111111);
+		sendData(xrange.second & 0b00111111);
+
+		sendCommand(Cmd::SET_RAM_Y_ADDR_POSITIONS);
+		sendData(yrange.first & 0xFF);
+		sendData((yrange.first >> 8) & 0b1);
+		sendData(yrange.second & 0xFF);
+		sendData((yrange.second >> 8) & 0b1);
+	}
+
+	static void setRamXPos(const std::uint8_t pos = Width / 8 - 1)
+	{
+		sendCommand(Cmd::SET_RAM_X_ADDR);
+		sendData(pos & 0b00111111);
+	}
+
+	static void setRamYPos(const std::uint16_t pos = 0)
+	{
+		sendCommand(Cmd::SET_RAM_Y_ADDR);
+		sendData(pos & 0xFF);
+		sendData((pos >> 8) & 0b1);
+	}
+
+	template <typename PrintFn>
+	static void dumpOTP(PrintFn &&printFn)
+	{
+		constexpr auto byteWidth = Width / 8;
+		constexpr auto ramHeight = Height + 46;
+
+		constexpr auto xRamRange = std::pair<std::uint8_t, std::uint8_t>{0, byteWidth - 1};
+		constexpr auto yRamRange = std::pair<std::uint16_t, std::uint16_t>{0, ramHeight - 1};
+
+		setDataEntryMode(RamDirection::INCREMENT, RamDirection::INCREMENT, FastestMovingIndex::X);
+		setRamRange(xRamRange, yRamRange);
+		setRamXPos(0);
+		setRamYPos(0);
+
+		sendCommand(Cmd::WRITE_RAM_BLACK);
+		for (auto i = std::uint16_t{0}; i < byteWidth * ramHeight; i++) {
+			sendData(0xFF);
+		}
+		sendCommand(Cmd::WRITE_RAM_RED);
+		for (auto i = std::uint16_t{0}; i < byteWidth * ramHeight; i++) {
 			sendData(0x00);
 		}
 
+		//////////////////////////////////////////////////////////////////////////
+
 		sendCommand(Cmd::DISPLAY_UPDATE_CONTROL_2);
-		sendData(0xF7);
+		sendData(0x80);
 		sendCommand(Cmd::UPDATE_DISPLAY);
 		waitUntilIdle();
+
+		sendCommand(Cmd::LOAD_OTP_TO_RAM);
+		waitUntilIdle();
+
+		setRamXPos(0);
+		setRamYPos(0);
+
+		sendCommand(Cmd::READ_RAM_CHANNEL);
+		sendData(static_cast<word_t>(Color::BLACK));
+
+		sendCommand(Cmd::READ_RAM);
+		readData(); // First byte must be discarded
+
+		for (auto i = std::size_t{0}; i < sizeof(OTP); ++i) {
+			printFn(readData());
+		}
+
+		init();
 	}
 
 	static void sleep()
@@ -211,13 +424,6 @@ class Eink {
 		sendData(0x01);
 		_delay_ms(100);
 	}
-
-	static void spiTransfer(const word_t data)
-	{
-		Spi::select(true);
-		Spi::transfer(data);
-		Spi::select(false);
-	}
 };
 
 } // namespace eink

eink_spi.hpp

@@ -0,0 +1,157 @@
+#pragma once
+
+#include "../clock.hpp"
+
+#include <type_traits>
+
+#include <cstdint>
+
+#include <avr/interrupt.h>
+
+#include "../io/io.hpp"
+#include "../util/util.hpp"
+
+namespace eink {
+
+template <io::P SclPin, io::P SdaPin, io::P CsPin, io::P DcPin, std::uint32_t Freq = 100'000>
+class Spi {
+	template <std::uint32_t StaticClockCycles>
+	static constexpr double calcClockDelay()
+	{
+		constexpr auto maxFrequency = F_CPU / StaticClockCycles;
+		static_assert(Freq <= maxFrequency, "SPI frequency not achievable using selected clock speed");
+		constexpr auto staticDelay = (1.0 * 1000 * 1000 / maxFrequency);
+		const auto delayUs = ((1.0 * 1000 * 1000 / Freq) - staticDelay) / 2;
+		return (delayUs > 0 ? delayUs : 0);
+	}
+
+	static constexpr double calcWriteClockDelay()
+	{
+		return calcClockDelay<8>();
+	}
+
+	static constexpr double calcReadClockDelay()
+	{
+		return calcClockDelay<5>();
+	}
+
+	static constexpr auto THREE_WIRE_SPI = (DcPin == io::P::NONE);
+
+  public:
+	using word_t = std::conditional_t<THREE_WIRE_SPI, std::uint16_t, std::uint8_t>;
+
+	static void init()
+	{
+		sm_scl = false;
+		sm_cs = true;
+
+		sm_scl.dir(io::Dir::OUT);
+		sm_sda.dir(io::Dir::OUT);
+		sm_cs.dir(io::Dir::OUT);
+		sm_dc.dir(io::Dir::OUT);
+	}
+
+	static void write(word_t data, const bool command = true)
+	{
+		constexpr auto numBits = THREE_WIRE_SPI ? 9 : 8;
+
+		const auto oldInterruptState = disableInterrupts();
+
+		sm_sda.dir(io::Dir::OUT);
+
+		if constexpr (THREE_WIRE_SPI) {
+			if (command) {
+				data &= ~(1 << 8);
+			} else {
+				data |= 1 << 8;
+			}
+		}
+
+		sm_dc = !command;
+
+		util::for_constexpr(
+		    [&](const auto idx) {
+			    constexpr auto bitPos = numBits - idx.value - 1;
+
+			    sm_sda = data >> bitPos & 1;
+
+			    _delay_us(WRITE_DELAY_US);
+			    sm_scl.toggle();
+
+			    _delay_us(WRITE_DELAY_US);
+			    sm_scl.toggle();
+		    },
+		    std::make_index_sequence<numBits>{});
+
+		enableInterrupts(oldInterruptState);
+	}
+
+	static word_t read()
+	{
+		constexpr auto numBits = 8;
+
+		const auto oldInterruptState = disableInterrupts();
+
+		if constexpr (THREE_WIRE_SPI) {
+			sm_sda = true;
+			_delay_us(READ_DELAY_US);
+			sm_scl.toggle();
+			_delay_us(READ_DELAY_US);
+			sm_scl.toggle();
+		}
+
+		sm_sda.pullup(false);
+		sm_sda.dir(io::Dir::IN);
+
+		sm_dc = true;
+
+		auto res = word_t{};
+
+		util::for_constexpr(
+		    [&](const auto idx) {
+			    constexpr auto bitPos = numBits - idx.value - 1;
+
+			    _delay_us(READ_DELAY_US);
+			    sm_scl.toggle();
+
+			    const auto receivedBit = sm_sda.read();
+			    res |= word_t{receivedBit} << bitPos;
+
+			    _delay_us(READ_DELAY_US);
+			    sm_scl.toggle();
+		    },
+		    std::make_index_sequence<numBits>{});
+
+		enableInterrupts(oldInterruptState);
+
+		return res;
+	}
+
+	static inline void select(const bool selectState)
+	{
+		sm_cs = !selectState;
+	}
+
+  private:
+	static io::Pin<SclPin> sm_scl;
+	static io::Pin<SdaPin> sm_sda;
+	static io::Pin<CsPin> sm_cs;
+	static io::Pin<DcPin> sm_dc;
+
+	static constexpr auto WRITE_DELAY_US = calcWriteClockDelay();
+	static constexpr auto READ_DELAY_US = calcReadClockDelay();
+
+	static inline std::uint8_t disableInterrupts()
+	{
+		const auto oldInterruptState = SREG;
+		cli();
+		return oldInterruptState;
+	}
+
+	static inline void enableInterrupts(const std::uint8_t oldInterruptState)
+	{
+		SREG = oldInterruptState;
+	}
+};
+
+} // namespace eink

font.hpp

@@ -0,0 +1,142 @@
+#pragma once
+
+#include <array>
+
+#include <cstdint>
+
+#include "../flash/flash.hpp"
+
+namespace eink {
+
+constexpr auto FONT_8X8 = flash::Wrapper{std::to_array<std::array<std::uint8_t, 8>>({
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0000 (nul)
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0001
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0002
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0003
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0004
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0005
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0006
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0007
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0008
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0009
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000A
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000B
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000C
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000D
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000E
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000F
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0010
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0011
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0012
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0013
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0014
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0015
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0016
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0017
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0018
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0019
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001A
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001B
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001C
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001D
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001E
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001F
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0020 (space)
+    {0x18, 0x3C, 0x3C, 0x18, 0x18, 0x00, 0x18, 0x00}, // U+0021 (!)
+    {0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0022 (")
+    {0x36, 0x36, 0x7F, 0x36, 0x7F, 0x36, 0x36, 0x00}, // U+0023 (#)
+    {0x0C, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x0C, 0x00}, // U+0024 ($)
+    {0x00, 0x63, 0x33, 0x18, 0x0C, 0x66, 0x63, 0x00}, // U+0025 (%)
+    {0x1C, 0x36, 0x1C, 0x6E, 0x3B, 0x33, 0x6E, 0x00}, // U+0026 (&)
+    {0x06, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0027 (')
+    {0x18, 0x0C, 0x06, 0x06, 0x06, 0x0C, 0x18, 0x00}, // U+0028 (()
+    {0x06, 0x0C, 0x18, 0x18, 0x18, 0x0C, 0x06, 0x00}, // U+0029 ())
+    {0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00}, // U+002A (*)
+    {0x00, 0x0C, 0x0C, 0x3F, 0x0C, 0x0C, 0x00, 0x00}, // U+002B (+)
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x06}, // U+002C (,)
+    {0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00}, // U+002D (-)
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x00}, // U+002E (.)
+    {0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x00}, // U+002F (/)
+    {0x3E, 0x63, 0x73, 0x7B, 0x6F, 0x67, 0x3E, 0x00}, // U+0030 (0)
+    {0x0C, 0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x3F, 0x00}, // U+0031 (1)
+    {0x1E, 0x33, 0x30, 0x1C, 0x06, 0x33, 0x3F, 0x00}, // U+0032 (2)
+    {0x1E, 0x33, 0x30, 0x1C, 0x30, 0x33, 0x1E, 0x00}, // U+0033 (3)
+    {0x38, 0x3C, 0x36, 0x33, 0x7F, 0x30, 0x78, 0x00}, // U+0034 (4)
+    {0x3F, 0x03, 0x1F, 0x30, 0x30, 0x33, 0x1E, 0x00}, // U+0035 (5)
+    {0x1C, 0x06, 0x03, 0x1F, 0x33, 0x33, 0x1E, 0x00}, // U+0036 (6)
+    {0x3F, 0x33, 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x00}, // U+0037 (7)
+    {0x1E, 0x33, 0x33, 0x1E, 0x33, 0x33, 0x1E, 0x00}, // U+0038 (8)
+    {0x1E, 0x33, 0x33, 0x3E, 0x30, 0x18, 0x0E, 0x00}, // U+0039 (9)
+    {0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x00}, // U+003A (:)
+    {0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x06}, // U+003B (;)
+    {0x18, 0x0C, 0x06, 0x03, 0x06, 0x0C, 0x18, 0x00}, // U+003C (<)
+    {0x00, 0x00, 0x3F, 0x00, 0x00, 0x3F, 0x00, 0x00}, // U+003D (=)
+    {0x06, 0x0C, 0x18, 0x30, 0x18, 0x0C, 0x06, 0x00}, // U+003E (>)
+    {0x1E, 0x33, 0x30, 0x18, 0x0C, 0x00, 0x0C, 0x00}, // U+003F (?)
+    {0x3E, 0x63, 0x7B, 0x7B, 0x7B, 0x03, 0x1E, 0x00}, // U+0040 (@)
+    {0x0C, 0x1E, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x00}, // U+0041 (A)
+    {0x3F, 0x66, 0x66, 0x3E, 0x66, 0x66, 0x3F, 0x00}, // U+0042 (B)
+    {0x3C, 0x66, 0x03, 0x03, 0x03, 0x66, 0x3C, 0x00}, // U+0043 (C)
+    {0x1F, 0x36, 0x66, 0x66, 0x66, 0x36, 0x1F, 0x00}, // U+0044 (D)
+    {0x7F, 0x46, 0x16, 0x1E, 0x16, 0x46, 0x7F, 0x00}, // U+0045 (E)
+    {0x7F, 0x46, 0x16, 0x1E, 0x16, 0x06, 0x0F, 0x00}, // U+0046 (F)
+    {0x3C, 0x66, 0x03, 0x03, 0x73, 0x66, 0x7C, 0x00}, // U+0047 (G)
+    {0x33, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x33, 0x00}, // U+0048 (H)
+    {0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0049 (I)
+    {0x78, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E, 0x00}, // U+004A (J)
+    {0x67, 0x66, 0x36, 0x1E, 0x36, 0x66, 0x67, 0x00}, // U+004B (K)
+    {0x0F, 0x06, 0x06, 0x06, 0x46, 0x66, 0x7F, 0x00}, // U+004C (L)
+    {0x63, 0x77, 0x7F, 0x7F, 0x6B, 0x63, 0x63, 0x00}, // U+004D (M)
+    {0x63, 0x67, 0x6F, 0x7B, 0x73, 0x63, 0x63, 0x00}, // U+004E (N)
+    {0x1C, 0x36, 0x63, 0x63, 0x63, 0x36, 0x1C, 0x00}, // U+004F (O)
+    {0x3F, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x0F, 0x00}, // U+0050 (P)
+    {0x1E, 0x33, 0x33, 0x33, 0x3B, 0x1E, 0x38, 0x00}, // U+0051 (Q)
+    {0x3F, 0x66, 0x66, 0x3E, 0x36, 0x66, 0x67, 0x00}, // U+0052 (R)
+    {0x1E, 0x33, 0x07, 0x0E, 0x38, 0x33, 0x1E, 0x00}, // U+0053 (S)
+    {0x3F, 0x2D, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0054 (T)
+    {0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0x00}, // U+0055 (U)
+    {0x33, 0x33, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00}, // U+0056 (V)
+    {0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00}, // U+0057 (W)
+    {0x63, 0x63, 0x36, 0x1C, 0x1C, 0x36, 0x63, 0x00}, // U+0058 (X)
+    {0x33, 0x33, 0x33, 0x1E, 0x0C, 0x0C, 0x1E, 0x00}, // U+0059 (Y)
+    {0x7F, 0x63, 0x31, 0x18, 0x4C, 0x66, 0x7F, 0x00}, // U+005A (Z)
+    {0x1E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x1E, 0x00}, // U+005B ([)
+    {0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x40, 0x00}, // U+005C (\)
+    {0x1E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1E, 0x00}, // U+005D (])
+    {0x08, 0x1C, 0x36, 0x63, 0x00, 0x00, 0x00, 0x00}, // U+005E (^)
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF}, // U+005F (_)
+    {0x0C, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0060 (`)
+    {0x00, 0x00, 0x1E, 0x30, 0x3E, 0x33, 0x6E, 0x00}, // U+0061 (a)
+    {0x07, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00}, // U+0062 (b)
+    {0x00, 0x00, 0x1E, 0x33, 0x03, 0x33, 0x1E, 0x00}, // U+0063 (c)
+    {0x38, 0x30, 0x30, 0x3e, 0x33, 0x33, 0x6E, 0x00}, // U+0064 (d)
+    {0x00, 0x00, 0x1E, 0x33, 0x3f, 0x03, 0x1E, 0x00}, // U+0065 (e)
+    {0x1C, 0x36, 0x06, 0x0f, 0x06, 0x06, 0x0F, 0x00}, // U+0066 (f)
+    {0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x1F}, // U+0067 (g)
+    {0x07, 0x06, 0x36, 0x6E, 0x66, 0x66, 0x67, 0x00}, // U+0068 (h)
+    {0x0C, 0x00, 0x0E, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0069 (i)
+    {0x30, 0x00, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E}, // U+006A (j)
+    {0x07, 0x06, 0x66, 0x36, 0x1E, 0x36, 0x67, 0x00}, // U+006B (k)
+    {0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+006C (l)
+    {0x00, 0x00, 0x33, 0x7F, 0x7F, 0x6B, 0x63, 0x00}, // U+006D (m)
+    {0x00, 0x00, 0x1F, 0x33, 0x33, 0x33, 0x33, 0x00}, // U+006E (n)
+    {0x00, 0x00, 0x1E, 0x33, 0x33, 0x33, 0x1E, 0x00}, // U+006F (o)
+    {0x00, 0x00, 0x3B, 0x66, 0x66, 0x3E, 0x06, 0x0F}, // U+0070 (p)
+    {0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x78}, // U+0071 (q)
+    {0x00, 0x00, 0x3B, 0x6E, 0x66, 0x06, 0x0F, 0x00}, // U+0072 (r)
+    {0x00, 0x00, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x00}, // U+0073 (s)
+    {0x08, 0x0C, 0x3E, 0x0C, 0x0C, 0x2C, 0x18, 0x00}, // U+0074 (t)
+    {0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x6E, 0x00}, // U+0075 (u)
+    {0x00, 0x00, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00}, // U+0076 (v)
+    {0x00, 0x00, 0x63, 0x6B, 0x7F, 0x7F, 0x36, 0x00}, // U+0077 (w)
+    {0x00, 0x00, 0x63, 0x36, 0x1C, 0x36, 0x63, 0x00}, // U+0078 (x)
+    {0x00, 0x00, 0x33, 0x33, 0x33, 0x3E, 0x30, 0x1F}, // U+0079 (y)
+    {0x00, 0x00, 0x3F, 0x19, 0x0C, 0x26, 0x3F, 0x00}, // U+007A (z)
+    {0x38, 0x0C, 0x0C, 0x07, 0x0C, 0x0C, 0x38, 0x00}, // U+007B ({)
+    {0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00}, // U+007C (|)
+    {0x07, 0x0C, 0x0C, 0x38, 0x0C, 0x0C, 0x07, 0x00}, // U+007D (})
+    {0x6E, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+007E (~)
+    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}  // U+007F
+})};
+
+} // namespace eink

otp.hpp

@@ -0,0 +1,353 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace eink {
+
+// [SOURCE]_[VCOM]
+enum class Voltage : std::uint8_t {
+	VSS1 = 0b00,
+	VSH1 = 0b01,
+	VSL1 = 0b10,
+	VSH2 = 0b11,
+};
+
+struct [[gnu::packed]] Phases
+{
+	Voltage phaseD : 2;
+	Voltage phaseC : 2;
+	Voltage phaseB : 2;
+	Voltage phaseA : 2;
+};
+static_assert(sizeof(Phases) == 1);
+
+struct [[gnu::packed]] VoltageGroups
+{
+	Phases group[12];
+};
+static_assert(sizeof(VoltageGroups) == 12);
+
+struct [[gnu::packed]] Timings
+{
+	std::uint8_t frameCountPhaseA;
+	std::uint8_t frameCountPhaseB;
+	std::uint8_t repeatSubPhaseAB;
+	std::uint8_t frameCountPhaseC;
+	std::uint8_t frameCountPhaseD;
+	std::uint8_t repeatSubPhaseCD;
+	std::uint8_t repeat;
+};
+static_assert(sizeof(Timings) == 7);
+
+struct [[gnu::packed]] FrameRates
+{
+	std::uint8_t group11 : 4;
+	std::uint8_t group10 : 4;
+	std::uint8_t group9 : 4;
+	std::uint8_t group8 : 4;
+	std::uint8_t group7 : 4;
+	std::uint8_t group6 : 4;
+	std::uint8_t group5 : 4;
+	std::uint8_t group4 : 4;
+	std::uint8_t group3 : 4;
+	std::uint8_t group2 : 4;
+	std::uint8_t group1 : 4;
+	std::uint8_t group0 : 4;
+};
+static_assert(sizeof(FrameRates) == 6);
+
+struct [[gnu::packed]] SubPhaseGateStates
+{
+	bool group11SubPhaseCD : 1;
+	bool group11SubPhaseAB : 1;
+	bool group10SubPhaseCD : 1;
+	bool group10SubPhaseAB : 1;
+	bool group9SubPhaseCD : 1;
+	bool group9SubPhaseAB : 1;
+	bool group8SubPhaseCD : 1;
+	bool group8SubPhaseAB : 1;
+	bool group7SubPhaseCD : 1;
+	bool group7SubPhaseAB : 1;
+	bool group6SubPhaseCD : 1;
+	bool group6SubPhaseAB : 1;
+	bool group5SubPhaseCD : 1;
+	bool group5SubPhaseAB : 1;
+	bool group4SubPhaseCD : 1;
+	bool group4SubPhaseAB : 1;
+	bool group3SubPhaseCD : 1;
+	bool group3SubPhaseAB : 1;
+	bool group2SubPhaseCD : 1;
+	bool group2SubPhaseAB : 1;
+	bool group1SubPhaseCD : 1;
+	bool group1SubPhaseAB : 1;
+	bool group0SubPhaseCD : 1;
+	bool group0SubPhaseAB : 1;
+};
+static_assert(sizeof(SubPhaseGateStates) == 3);
+
+struct [[gnu::packed]] Waveform
+{
+	VoltageGroups lut[5];
+	Timings timings[12];
+	FrameRates frameRates;
+	SubPhaseGateStates subPhaseGateStates;
+};
+static_assert(sizeof(Waveform) == 153);
+
+enum class LutEndOption : std::uint8_t {
+	KEEP_PREVIOUS_SOURCE_OUTPUT_LEVEL_BEFORE_POWER_OFF = 0x07,
+	NORMAL = 0x22,
+};
+static_assert(sizeof(LutEndOption) == 1);
+
+enum class GateVoltage : std::uint8_t {
+	V_20_DEFAULT = 0x00,
+	V_10 = 0x03,
+	V_10_5 = 0x04,
+	V_11 = 0x05,
+	V_11_5 = 0x06,
+	V_12 = 0x07,
+	V_12_5 = 0x08,
+	V_13 = 0x09,
+	V_13_5 = 0x0A,
+	V_14 = 0x0B,
+	V_14_5 = 0x0C,
+	V_15 = 0x0D,
+	V_15_5 = 0x0E,
+	V_16 = 0x0F,
+	V_16_5 = 0x10,
+	V_17 = 0x11,
+	V_17_5 = 0x12,
+	V_18 = 0x13,
+	V_18_5 = 0x14,
+	V_19 = 0x15,
+	V_19_5 = 0x16,
+	V_20 = 0x17,
+};
+static_assert(sizeof(GateVoltage) == 1);
+
+enum class VoltageSourceHigh : std::uint8_t {
+	V_9 = 0x23,
+	V_9_2 = 0x24,
+	V_9_4 = 0x25,
+	V_9_6 = 0x26,
+	V_9_8 = 0x27,
+	V_10 = 0x28,
+	V_10_2 = 0x29,
+	V_10_4 = 0x2A,
+	V_10_6 = 0x2B,
+	V_10_8 = 0x2C,
+	V_11 = 0x2D,
+	V_11_2 = 0x2E,
+	V_11_4 = 0x2F,
+	V_11_6 = 0x30,
+	V_11_8 = 0x31,
+	V_12 = 0x32,
+	V_12_2 = 0x33,
+	V_12_4 = 0x34,
+	V_12_6 = 0x35,
+	V_12_8 = 0x36,
+	V_13 = 0x37,
+	V_13_2 = 0x38,
+	V_13_4 = 0x39,
+	V_13_6 = 0x3A,
+	V_13_8 = 0x3B,
+	V_14 = 0x3C,
+	V_14_2 = 0x3D,
+	V_14_4 = 0x3E,
+	V_14_6 = 0x3F,
+	V_14_8 = 0x40,
+	V_15 = 0x41,
+	V_15_2 = 0x42,
+	V_15_4 = 0x43,
+	V_15_6 = 0x44,
+	V_15_8 = 0x45,
+	V_16 = 0x46,
+	V_16_2 = 0x47,
+	V_16_4 = 0x48,
+	V_16_6 = 0x49,
+	V_16_8 = 0x4A,
+	V_17 = 0x4B,
+	V_2_4 = 0x8E,
+	V_2_5 = 0x8F,
+	V_2_6 = 0x90,
+	V_2_7 = 0x91,
+	V_2_8 = 0x92,
+	V_2_9 = 0x93,
+	V_3 = 0x94,
+	V_3_1 = 0x95,
+	V_3_2 = 0x96,
+	V_3_3 = 0x97,
+	V_3_4 = 0x98,
+	V_3_5 = 0x99,
+	V_3_6 = 0x9A,
+	V_3_7 = 0x9B,
+	V_3_8 = 0x9C,
+	V_3_9 = 0x9D,
+	V_4 = 0x9E,
+	V_4_1 = 0x9F,
+	V_4_2 = 0xA0,
+	V_4_3 = 0xA1,
+	V_4_4 = 0xA2,
+	V_4_5 = 0xA3,
+	V_4_6 = 0xA4,
+	V_4_7 = 0xA5,
+	V_4_8 = 0xA6,
+	V_4_9 = 0xA7,
+	V_5 = 0xA8,
+	V_5_1 = 0xA9,
+	V_5_2 = 0xAA,
+	V_5_3 = 0xAB,
+	V_5_4 = 0xAC,
+	V_5_5 = 0xAD,
+	V_5_6 = 0xAE,
+	V_5_7 = 0xAF,
+	V_5_8 = 0xB0,
+	V_5_9 = 0xB1,
+	V_6 = 0xB2,
+	V_6_1 = 0xB3,
+	V_6_2 = 0xB4,
+	V_6_3 = 0xB5,
+	V_6_4 = 0xB6,
+	V_6_5 = 0xB7,
+	V_6_6 = 0xB8,
+	V_6_7 = 0xB9,
+	V_6_8 = 0xBA,
+	V_6_9 = 0xBB,
+	V_7 = 0xBC,
+	V_7_1 = 0xBD,
+	V_7_2 = 0xBE,
+	V_7_3 = 0xBF,
+	V_7_4 = 0xC0,
+	V_7_5 = 0xC1,
+	V_7_6 = 0xC2,
+	V_7_7 = 0xC3,
+	V_7_8 = 0xC4,
+	V_7_9 = 0xC5,
+	V_8 = 0xC6,
+	V_8_1 = 0xC7,
+	V_8_2 = 0xC8,
+	V_8_3 = 0xC9,
+	V_8_4 = 0xCA,
+	V_8_5 = 0xCB,
+	V_8_6 = 0xCC,
+	V_8_7 = 0xCD,
+	V_8_8 = 0xCE,
+};
+static_assert(sizeof(VoltageSourceHigh) == 1);
+
+enum class VoltageSourceLow : std::uint8_t {
+	NEG_5 = 0x0A,
+	NEG_5_5 = 0x0C,
+	NEG_6 = 0x0E,
+	NEG_6_5 = 0x10,
+	NEG_7 = 0x12,
+	NEG_7_5 = 0x14,
+	NEG_8 = 0x16,
+	NEG_8_5 = 0x18,
+	NEG_9 = 0x1A,
+	NEG_9_5 = 0x1C,
+	NEG_10 = 0x1E,
+	NEG_10_5 = 0x20,
+	NEG_11 = 0x22,
+	NEG_11_5 = 0x24,
+	NEG_12 = 0x26,
+	NEG_12_5 = 0x28,
+	NEG_13 = 0x2A,
+	NEG_13_5 = 0x2C,
+	NEG_14 = 0x2E,
+	NEG_14_5 = 0x30,
+	NEG_15 = 0x32,
+	NEG_15_5 = 0x34,
+	NEG_16 = 0x36,
+	NEG_16_5 = 0x38,
+	NEG_17 = 0x3A,
+};
+static_assert(sizeof(VoltageSourceLow) == 1);
+
+struct [[gnu::packed]] SourceVoltage
+{
+	VoltageSourceHigh vsh1;
+	VoltageSourceHigh vsh2;
+	VoltageSourceLow vsl;
+};
+static_assert(sizeof(SourceVoltage) == 3);
+
+enum class CommonVoltage : std::uint8_t {
+	NEG_0_2 = 0x08,
+	NEG_0_3 = 0x0C,
+	NEG_0_4 = 0x10,
+	NEG_0_5 = 0x14,
+	NEG_0_6 = 0x18,
+	NEG_0_7 = 0x1C,
+	NEG_0_8 = 0x20,
+	NEG_0_9 = 0x24,
+	NEG_1 = 0x28,
+	NEG_1_1 = 0x2C,
+	NEG_1_2 = 0x30,
+	NEG_1_3 = 0x34,
+	NEG_1_4 = 0x38,
+	NEG_1_5 = 0x3C,
+	NEG_1_6 = 0x40,
+	NEG_1_7 = 0x44,
+	NEG_1_8 = 0x48,
+	NEG_1_9 = 0x4C,
+	NEG_2 = 0x50,
+	NEG_2_1 = 0x54,
+	NEG_2_2 = 0x58,
+	NEG_2_3 = 0x5C,
+	NEG_2_4 = 0x60,
+	NEG_2_5 = 0x64,
+	NEG_2_6 = 0x68,
+	NEG_2_7 = 0x6C,
+	NEG_2_8 = 0x70,
+	NEG_2_9 = 0x74,
+	NEG_3 = 0x78,
+};
+static_assert(sizeof(CommonVoltage) == 1);
+
+struct [[gnu::packed]] WaveformSetting
+{
+	Waveform waveform;
+	LutEndOption lutEndOption;
+	GateVoltage gateVoltage;
+	SourceVoltage sourceVoltage;
+	CommonVoltage commonVoltage;
+};
+static_assert(sizeof(WaveformSetting) == 159);
+
+struct [[gnu::packed]] TemperatureRange
+{
+	std::uint8_t lowerBoundLowBits;
+	std::uint8_t lowerBoundHighBits : 4;
+	std::uint8_t upperBoundLowBits : 4;
+	std::uint8_t upperBoundHighBits;
+
+	inline constexpr operator std::pair<float, float>() const
+	{
+		constexpr auto convertTemp = [](const auto &temp) {
+			auto signedTemp = static_cast<std::int16_t>(temp);
+			if (signedTemp >> 11 & 1) {
+				signedTemp |= 0b1111 << 12;
+			}
+			const auto tempDegrees = signedTemp / 16.0f;
+			return tempDegrees;
+		};
+
+		const auto lowerBound = static_cast<std::uint16_t>(lowerBoundHighBits) << 8 | lowerBoundLowBits;
+		const auto upperBound = static_cast<std::uint16_t>(upperBoundHighBits) << 4 | upperBoundLowBits;
+
+		return {convertTemp(lowerBound), convertTemp(upperBound)};
+	};
+};
+static_assert(sizeof(TemperatureRange) == 3);
+
+struct [[gnu::packed]] OTP
+{
+	WaveformSetting waveforms[36];
+	TemperatureRange temperatures[36];
+};
+static_assert(sizeof(OTP) == 5832);
+
+} // namespace eink