avr/eink
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: avr:master
Branches Tags
avr:master
avr:example
..
compare: avr:example
Branches Tags
avr:example
avr:master

No commits in common. "master" and "example" have entirely different histories.
master ... example

17 changed files with 1124 additions and 1081 deletions
Show Stats Expand all files Collapse all files

18
.gitmodules vendored Normal file
View File

@ -0,0 +1,18 @@
[submodule "eink/eink"]
path = eink/eink
url = git@git.blackmark.me:avr/eink.git
[submodule "eink/uart"]
path = eink/uart
url = git@git.blackmark.me:avr/uart.git
[submodule "eink/io"]
path = eink/io
url = git@git.blackmark.me:avr/io.git
[submodule "eink/util"]
path = eink/util
url = git@git.blackmark.me:avr/util.git
[submodule "eink/flash"]
path = eink/flash
url = git@git.blackmark.me:avr/flash.git
[submodule "eink/avr-libstdcpp"]
path = eink/avr-libstdcpp
url = git@github.com:modm-io/avr-libstdcpp.git

22
eink.atsln Normal file
View File

@ -0,0 +1,22 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Atmel Studio Solution File, Format Version 11.00
VisualStudioVersion = 14.0.23107.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{E66E83B9-2572-4076-B26E-6BE79FF3018A}") = "eink", "eink\eink.cppproj", "{DCE6C7E3-EE26-4D79-826B-08594B9AD897}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|AVR = Debug|AVR
Release|AVR = Release|AVR
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Debug|AVR.ActiveCfg = Debug|AVR
{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Debug|AVR.Build.0 = Debug|AVR
{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Release|AVR.ActiveCfg = Release|AVR
{DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Release|AVR.Build.0 = Release|AVR
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

429
eink.hpp
View File

@ -1,429 +0,0 @@
#pragma once
#include <tuple>
#include <type_traits>
#include <utility>
#include <cstddef>
#include <cstdint>
#include <cstring>
#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 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,
DATA_ENTRY_MODE = 0x11,
SW_RESET = 0x12,
READ_TEMPERATURE_SENSOR = 0x18,
UPDATE_DISPLAY = 0x20,
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,
};
enum class Color : std::uint8_t {
BLACK = 0x00,
RED = 0x01,
WHITE = 0x02,
};
enum class RamDirection : std::uint8_t {
DECREMENT = 0,
INCREMENT = 1,
};
enum class FastestMovingIndex : std::uint8_t {
X = 0,
Y = 1,
};
static void init()
{
m_rst.dir(io::Dir::OUT);
m_busy.pullup(false);
m_busy.dir(io::Dir::IN);
Spi::init();
reset();
softReset();
sendCommand(Cmd::DRIVER_OUTPUT_CONTROL);
sendData(0xC7);
sendData(0x00);
sendData(0x01);
setDataEntryMode(RamDirection::DECREMENT, RamDirection::INCREMENT, FastestMovingIndex::X);
setRamRange();
setRamXPos();
setRamYPos();
sendCommand(Cmd::BORDER_WAVEFORM_CONTROL);
sendData(0x05);
sendCommand(Cmd::READ_TEMPERATURE_SENSOR);
sendData(0x80);
waitUntilIdle();
}
static void sendCommand(const Cmd command)
{
Spi::select(true);
Spi::write(static_cast<word_t>(command), true);
Spi::select(false);
}
static void sendData(word_t data)
{
Spi::select(true);
Spi::write(data, false);
Spi::select(false);
}
static word_t readData()
{
Spi::select(true);
const auto res = Spi::read();
Spi::select(false);
return res;
}
static void waitUntilIdle()
{
while (m_busy) {
_delay_ms(100);
}
}
static void reset()
{
m_rst = true;
_delay_ms(200);
m_rst = false;
_delay_ms(10);
m_rst = true;
_delay_ms(200);
waitUntilIdle();
}
static void softReset()
{
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)>;
sendCommand(command);
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, std::get<0>(rleImage.value));
sendImageChannel(Cmd::WRITE_RAM_RED, std::get<1>(rleImage.value));
}
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(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(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()
{
sendCommand(Cmd::DEEP_SLEEP_MODE);
sendData(0x01);
_delay_ms(100);
}
};
} // namespace eink

159
eink/Makefile Normal file
View File

@ -0,0 +1,159 @@
# Makefile for AVR C++ projects
# From: https://gist.github.com/rynr/72734da4b8c7b962aa65
# ----- Update the settings of your project here -----
# Hardware
MCU = atmega328p
AVRDUDE_PARAMS = -c atmelice_isp
FUSES = -U lfuse:w:0xff:m -U hfuse:w:0xd7:m -U efuse:w:0xfd:m
# Parameters
PROJECT = $(lastword $(subst /, ,$(CURDIR)))
INCS = -isystem avr-libstdcpp/include
LIBS =
DEFS = -DNDEBUG
# ----- These configurations are quite likely not to be changed -----
# Binaries
GCC = avr-gcc
G++ = avr-g++
RM = rm -f
AVRDUDE = avrdude
OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump
SIZE = avr-size
# Files
EXT_C = c
EXT_C++ = cpp
EXT_ASM = asm
# ----- No changes should be necessary below this line -----
OBJECTS = \
$(patsubst %.$(EXT_C),%.o,$(wildcard *.$(EXT_C)) $(wildcard **/*.$(EXT_C))) \
$(patsubst %.$(EXT_C++),%.o,$(wildcard *.$(EXT_C++)) $(wildcard **/*.$(EXT_C++))) \
$(patsubst %.$(EXT_ASM),%.o,$(wildcard *.$(EXT_ASM)) $(wildcard **/*.$(EXT_ASM)))
# Linker and compiler flags
LDFLAGS = $(LIBS)
LDFLAGS += -Wl,-Map=$(PROJECT).map
LDFLAGS += -Wl,--gc-sections -mrelax
CFLAGS = $(INCS)
CFLAGS += $(DEFS)
CFLAGS += -Os
CFLAGS += -std=c17
CFLAGS += -funsigned-char -funsigned-bitfields -fshort-enums -ffunction-sections -fdata-sections -fno-threadsafe-statics -mrelax
CFLAGS += -Wall -Wextra -pedantic -Wstrict-prototypes
CFLAGS += -mmcu=$(MCU)
C++FLAGS = $(INCS)
C++FLAGS += $(DEFS)
C++FLAGS += -Os
C++FLAGS += -std=c++20
C++FLAGS += -funsigned-char -funsigned-bitfields -fshort-enums -ffunction-sections -fdata-sections -fno-threadsafe-statics -mrelax
C++FLAGS += -Wall -Wextra -pedantic -Wno-array-bounds
C++FLAGS += -mmcu=$(MCU)
ASMFLAGS = $(INCS)
ASMFLAGS += $(DEFS)
ASMFLAGS += -Os
ASMFLAGS += -funsigned-char -funsigned-bitfields -fshort-enums -ffunction-sections -fdata-sections -fno-threadsafe-statics -mrelax
ASMFLAGS += -Wall -Wextra -pedantic -Wstrict-prototypes
ASMFLAGS += -x assembler-with-cpp
ASMFLAGS += -mmcu=$(MCU)
all: $(PROJECT).elf $(OBJECTS) $(PROJECT).hex $(PROJECT).srec $(PROJECT).eeprom $(PROJECT).lss
$(SIZE) -C --mcu=$(MCU) $(PROJECT).elf
%.elf: $(OBJECTS)
$(GCC) $(CFLAGS) $(OBJECTS) -o $@ $(LDFLAGS)
%.o: %.$(EXT_C)
$(GCC) $(CFLAGS) -c $< -o $@
%.o: %.$(EXT_C++)
$(G++) $(C++FLAGS) -c $< -o $@
%.o: %.$(EXT_ASM)
$(G++) $(ASMFLAGS) -c $< -o $@
%.hex: %.elf
$(OBJCOPY) -j .text -j .data -O ihex $< $@
%.srec: %.elf
$(OBJCOPY) -j .text -j .data -O srec $< $@
%.eeprom: %.elf
$(OBJCOPY) -j .eeprom --change-section-lma .eeprom=0 -O ihex $< $@
%.lss: %.elf
$(OBJDUMP) -h -S $< > $@
clean:
$(RM) $(PROJECT).elf $(OBJECTS) $(PROJECT).hex $(PROJECT).srec $(PROJECT).eeprom $(PROJECT).lss $(PROJECT).map
flash: $(PROJECT).hex
sudo $(AVRDUDE) $(AVRDUDE_PARAMS) -p $(MCU) -U flash:w:$<:i
flash-eeprom: $(PROJECT).eeprom
sudo $(AVRDUDE) $(AVRDUDE_PARAMS) -p $(MCU) -U eeprom:w:$<:i
flash-fuses:
sudo $(AVRDUDE) $(AVRDUDE_PARAMS) -p $(MCU) $(FUSES)
flash-erase:
sudo $(AVRDUDE) $(AVRDUDE_PARAMS) -p $(MCU) -e
help:
@echo "usage:"
@echo " make <target>"
@echo ""
@echo "targets:"
@echo " all Builds everything"
@echo " clean Remove any non-source files"
@echo " flash Flashes firmware"
@echo " flash-eeprom Flashes eeprom"
@echo " flash-fuses Flashes fuses"
@echo " flash-erase Erases entire chip including eeprom"
@echo " help Shows this help"
@echo " config Shows the current configuration"
@echo " show-mcu Show list of all possible MCUs"
config:
@echo "configuration:"
@echo ""
@echo "Binaries for:"
@echo " C compiler: $(GCC)"
@echo " C++ compiler: $(G++)"
@echo " remove files $(RM)"
@echo " Programmer: $(AVRDUDE)"
@echo " Obj copier: $(OBJCOPY)"
@echo " Obj dumper: $(OBJDUMP)"
@echo " Size calc: $(SIZE)"
@echo ""
@echo "Hardware settings:"
@echo " MCU: $(MCU)"
@echo " Avrdude params: $(AVRDUDE_PARAMS)"
@echo " Fuses: $(FUSES)"
@echo ""
@echo "Project settings:"
@echo " Project name: $(PROJECT)"
@echo " Include dirs: $(INCS)"
@echo " Library dirs: $(LIBS)"
@echo " Preprocessor defs: $(DEFS)"
@echo " C compiler flags: $(CFLAGS)"
@echo " C++ compiler flags: $(C++FLAGS)"
@echo " ASM compiler flags: $(ASMFLAGS)"
@echo " Linker flags: $(LDFLAGS)"
@echo ""
@echo "Defaults:"
@echo " C-files: *.$(EXT_C)"
@echo " C++-files: *.$(EXT_C++)"
@echo " ASM-files: *.$(EXT_ASM)"
show-mcu:
$(G++) --target-help

1
eink/avr-libstdcpp Submodule

@ -0,0 +1 @@
Subproject commit d289637d14cb9928a3690be4f2934aa2920f0f38

4
eink/clock.hpp Normal file
View File

@ -0,0 +1,4 @@
#pragma once
#define F_CPU 16'000'000
#include <util/delay.h>

1
eink/eink Submodule

@ -0,0 +1 @@
Subproject commit 827decfcbd19a2e40a76e70992c10af133b60416

275
eink/eink.cppproj Normal file
View File

@ -0,0 +1,275 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="14.0">
<PropertyGroup>
<SchemaVersion>2.0</SchemaVersion>
<ProjectVersion>7.0</ProjectVersion>
<ToolchainName>com.Atmel.AVRGCC8.CPP</ToolchainName>
<ProjectGuid>dce6c7e3-ee26-4d79-826b-08594b9ad897</ProjectGuid>
<avrdevice>ATmega328P</avrdevice>
<avrdeviceseries>none</avrdeviceseries>
<OutputType>Executable</OutputType>
<Language>CPP</Language>
<OutputFileName>$(MSBuildProjectName)</OutputFileName>
<OutputFileExtension>.elf</OutputFileExtension>
<OutputDirectory>$(MSBuildProjectDirectory)\$(Configuration)</OutputDirectory>
<AssemblyName>eink</AssemblyName>
<Name>eink</Name>
<RootNamespace>eink</RootNamespace>
<ToolchainFlavour>avr-g++-12.1.0</ToolchainFlavour>
<KeepTimersRunning>true</KeepTimersRunning>
<OverrideVtor>false</OverrideVtor>
<CacheFlash>true</CacheFlash>
<ProgFlashFromRam>true</ProgFlashFromRam>
<RamSnippetAddress>0x20000000</RamSnippetAddress>
<UncachedRange />
<preserveEEPROM>true</preserveEEPROM>
<OverrideVtorValue>exception_table</OverrideVtorValue>
<BootSegment>2</BootSegment>
<ResetRule>0</ResetRule>
<eraseonlaunchrule>0</eraseonlaunchrule>
<EraseKey />
<avrtool>com.atmel.avrdbg.tool.atmelice</avrtool>
<avrtoolserialnumber>J41800099437</avrtoolserialnumber>
<avrdeviceexpectedsignature>0x1E950F</avrdeviceexpectedsignature>
<com_atmel_avrdbg_tool_stk500>
<ToolOptions>
<InterfaceProperties>
<IspClock>125000</IspClock>
</InterfaceProperties>
<InterfaceName>ISP</InterfaceName>
</ToolOptions>
<ToolType>com.atmel.avrdbg.tool.stk500</ToolType>
<ToolNumber>
</ToolNumber>
<ToolName>STK500</ToolName>
</com_atmel_avrdbg_tool_stk500>
<avrtoolinterface>ISP</avrtoolinterface>
<avrtoolinterfaceclock>125000</avrtoolinterfaceclock>
<AsfFrameworkConfig>
<framework-data xmlns="">
<options />
<configurations />
<files />
<documentation help="" />
<offline-documentation help="" />
<dependencies>
<content-extension eid="atmel.asf" uuidref="Atmel.ASF" version="3.47.0" />
</dependencies>
</framework-data>
</AsfFrameworkConfig>
<com_atmel_avrdbg_tool_atmelice>
<ToolOptions>
<InterfaceProperties>
<IspClock>125000</IspClock>
</InterfaceProperties>
<InterfaceName>ISP</InterfaceName>
</ToolOptions>
<ToolType>com.atmel.avrdbg.tool.atmelice</ToolType>
<ToolNumber>J41800099437</ToolNumber>
<ToolName>Atmel-ICE</ToolName>
</com_atmel_avrdbg_tool_atmelice>
<custom>
<ToolOptions>
<InterfaceProperties>
<IspClock>125000</IspClock>
</InterfaceProperties>
<InterfaceName>
</InterfaceName>
</ToolOptions>
<ToolType>custom</ToolType>
<ToolNumber>
</ToolNumber>
<ToolName>Custom Programming Tool</ToolName>
</custom>
<AAFDebugger>
<AAFDebugFiles>
<DebugFile>
<path>\Debug\eink.lss</path>
<AAFSetting>
<Label>Lss Files</Label>
<Extention>.lss</Extention>
<Regex>^\s*(?&lt;address&gt;[a-f0-9]*):\s*.*$</Regex>
<DebugEnabled>true</DebugEnabled>
<RegexGroups>address</RegexGroups>
<DebuggerExpression>$pc</DebuggerExpression>
</AAFSetting>
</DebugFile>
</AAFDebugFiles>
</AAFDebugger>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<ToolchainSettings>
<AvrGccCpp>
<avrgcc.common.Device>-mmcu=atmega328p</avrgcc.common.Device>
<avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
<avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
<avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
<avrgcc.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec>
<avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures>
<avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
<avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
<avrgcc.compiler.symbols.DefSymbols>
<ListValues>
<Value>NDEBUG</Value>
</ListValues>
</avrgcc.compiler.symbols.DefSymbols>
<avrgcc.compiler.directories.IncludePaths>
<ListValues>
<Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
</ListValues>
</avrgcc.compiler.directories.IncludePaths>
<avrgcc.compiler.optimization.level>Optimize for size (-Os)</avrgcc.compiler.optimization.level>
<avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
<avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
<avrgcc.compiler.warnings.ExtraWarnings>True</avrgcc.compiler.warnings.ExtraWarnings>
<avrgcc.compiler.warnings.Pedantic>True</avrgcc.compiler.warnings.Pedantic>
<avrgcc.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -std=c17</avrgcc.compiler.miscellaneous.OtherFlags>
<avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>
<avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>
<avrgcccpp.compiler.symbols.DefSymbols>
<ListValues>
<Value>NDEBUG</Value>
</ListValues>
</avrgcccpp.compiler.symbols.DefSymbols>
<avrgcccpp.compiler.directories.IncludePaths>
<ListValues>
<Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
</ListValues>
</avrgcccpp.compiler.directories.IncludePaths>
<avrgcccpp.compiler.optimization.level>Optimize for size (-Os)</avrgcccpp.compiler.optimization.level>
<avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>
<avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
<avrgcccpp.compiler.warnings.Pedantic>True</avrgcccpp.compiler.warnings.Pedantic>
<avrgcccpp.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -Wextra -Wno-array-bounds -std=c++20 -isystem"%24(ProjectDir)/avr-libstdcpp/include"</avrgcccpp.compiler.miscellaneous.OtherFlags>
<avrgcccpp.linker.libraries.Libraries>
<ListValues>
<Value>libm</Value>
</ListValues>
</avrgcccpp.linker.libraries.Libraries>
<avrgcccpp.assembler.general.IncludePaths>
<ListValues>
<Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
</ListValues>
</avrgcccpp.assembler.general.IncludePaths>
</AvrGccCpp>
</ToolchainSettings>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<ToolchainSettings>
<AvrGccCpp>
<avrgcc.common.Device>-mmcu=atmega328p</avrgcc.common.Device>
<avrgcc.common.outputfiles.hex>True</avrgcc.common.outputfiles.hex>
<avrgcc.common.outputfiles.lss>True</avrgcc.common.outputfiles.lss>
<avrgcc.common.outputfiles.eep>True</avrgcc.common.outputfiles.eep>
<avrgcc.common.outputfiles.srec>True</avrgcc.common.outputfiles.srec>
<avrgcc.common.outputfiles.usersignatures>False</avrgcc.common.outputfiles.usersignatures>
<avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcc.compiler.general.ChangeDefaultCharTypeUnsigned>
<avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcc.compiler.general.ChangeDefaultBitFieldUnsigned>
<avrgcc.compiler.symbols.DefSymbols>
<ListValues>
<Value>DEBUG</Value>
</ListValues>
</avrgcc.compiler.symbols.DefSymbols>
<avrgcc.compiler.directories.IncludePaths>
<ListValues>
<Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
</ListValues>
</avrgcc.compiler.directories.IncludePaths>
<avrgcc.compiler.optimization.level>Optimize (-O1)</avrgcc.compiler.optimization.level>
<avrgcc.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcc.compiler.optimization.AllocateBytesNeededForEnum>
<avrgcc.compiler.optimization.DebugLevel>Maximum (-g3)</avrgcc.compiler.optimization.DebugLevel>
<avrgcc.compiler.warnings.AllWarnings>True</avrgcc.compiler.warnings.AllWarnings>
<avrgcc.compiler.warnings.ExtraWarnings>True</avrgcc.compiler.warnings.ExtraWarnings>
<avrgcc.compiler.warnings.Pedantic>True</avrgcc.compiler.warnings.Pedantic>
<avrgcc.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -std=c17</avrgcc.compiler.miscellaneous.OtherFlags>
<avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultCharTypeUnsigned>
<avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>True</avrgcccpp.compiler.general.ChangeDefaultBitFieldUnsigned>
<avrgcccpp.compiler.symbols.DefSymbols>
<ListValues>
<Value>DEBUG</Value>
</ListValues>
</avrgcccpp.compiler.symbols.DefSymbols>
<avrgcccpp.compiler.directories.IncludePaths>
<ListValues>
<Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
</ListValues>
</avrgcccpp.compiler.directories.IncludePaths>
<avrgcccpp.compiler.optimization.level>Optimize (-O1)</avrgcccpp.compiler.optimization.level>
<avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>True</avrgcccpp.compiler.optimization.AllocateBytesNeededForEnum>
<avrgcccpp.compiler.optimization.DebugLevel>Maximum (-g3)</avrgcccpp.compiler.optimization.DebugLevel>
<avrgcccpp.compiler.warnings.AllWarnings>True</avrgcccpp.compiler.warnings.AllWarnings>
<avrgcccpp.compiler.warnings.Pedantic>True</avrgcccpp.compiler.warnings.Pedantic>
<avrgcccpp.compiler.miscellaneous.OtherFlags>-fno-threadsafe-statics -Wextra -std=c++20 -isystem"%24(ProjectDir)/avr-libstdcpp/include"</avrgcccpp.compiler.miscellaneous.OtherFlags>
<avrgcccpp.linker.libraries.Libraries>
<ListValues>
<Value>libm</Value>
</ListValues>
</avrgcccpp.linker.libraries.Libraries>
<avrgcccpp.assembler.general.IncludePaths>
<ListValues>
<Value>%24(PackRepoDir)\Atmel\ATmega_DFP\1.4.346\include</Value>
</ListValues>
</avrgcccpp.assembler.general.IncludePaths>
<avrgcccpp.assembler.debugging.DebugLevel>Default (-Wa,-g)</avrgcccpp.assembler.debugging.DebugLevel>
</AvrGccCpp>
</ToolchainSettings>
</PropertyGroup>
<ItemGroup>
<Compile Include="clock.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="eink\eink_spi.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="eink\eink.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="eink\font.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="eink\otp.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="flash\flash.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="image.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="io\io.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="main.cpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="uart\config.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="uart\hardware.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="uart\hardware0.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="uart\hardware1.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="uart\software.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="uart\uart.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="util\util.hpp">
<SubType>compile</SubType>
</Compile>
</ItemGroup>
<ItemGroup>
<Folder Include="flash" />
<Folder Include="io" />
<Folder Include="eink" />
<Folder Include="util" />
<Folder Include="uart" />
</ItemGroup>
<Import Project="$(AVRSTUDIO_EXE_PATH)\\Vs\\Compiler.targets" />
</Project>

1
eink/flash Submodule

@ -0,0 +1 @@
Subproject commit ceec87f9219c1a380ff29dd93545d2596d9c8165

288
eink/image.hpp Normal file
View File

@ -0,0 +1,288 @@
#pragma once
#include <array>
#include <tuple>
#include <utility>
#include <cstdint>
#include "flash/flash.hpp"
constexpr auto RLE_IMAGE = flash::Wrapper{std::tuple{
std::to_array<std::pair<std::uint8_t, std::uint8_t>>({
{255, 0xff}, {17, 0xff}, {1, 0x0f}, {3, 0xff}, {1, 0xc0}, {2, 0x00}, {1, 0x01}, {7, 0xff}, {1, 0xfe},
{1, 0x07}, {1, 0xf0}, {1, 0x3f}, {2, 0xff}, {1, 0xfe}, {1, 0x07}, {1, 0xf0}, {1, 0x3e}, {1, 0x07},
{1, 0xe0}, {1, 0x3f}, {1, 0xff}, {1, 0xc0}, {3, 0x00}, {1, 0x3f}, {6, 0xff}, {1, 0xf8}, {1, 0x03},
{1, 0xc0}, {1, 0x1f}, {2, 0xff}, {1, 0xf8}, {1, 0x03}, {1, 0xe0}, {1, 0x1e}, {1, 0x67}, {1, 0x80},
{1, 0x1f}, {1, 0xff}, {1, 0xc0}, {3, 0x00}, {1, 0x0f}, {6, 0xff}, {1, 0xf8}, {1, 0xe1}, {1, 0xe7},
{1, 0x0f}, {2, 0xff}, {1, 0xf8}, {1, 0xe1}, {1, 0xc3}, {1, 0x0c}, {1, 0xf3}, {1, 0x02}, {1, 0x3f},
{1, 0xff}, {1, 0xc0}, {3, 0x00}, {1, 0x03}, {6, 0xff}, {1, 0xfd}, {1, 0xf1}, {1, 0xff}, {1, 0x8f},
{2, 0xff}, {1, 0xfd}, {1, 0xf1}, {1, 0xc7}, {1, 0x8e}, {1, 0xf7}, {1, 0x0f}, {1, 0xbf}, {1, 0xff},
{1, 0xc0}, {2, 0x00}, {2, 0x01}, {7, 0xff}, {1, 0xf1}, {1, 0xff}, {1, 0x8f}, {1, 0xf7}, {2, 0xff},
{1, 0xf1}, {1, 0xc7}, {1, 0x8e}, {1, 0x06}, {1, 0x1f}, {2, 0xff}, {1, 0xc0}, {2, 0x00}, {1, 0x03},
{1, 0x00}, {7, 0xff}, {1, 0xf1}, {1, 0xff}, {1, 0x8f}, {1, 0x80}, {2, 0xff}, {1, 0xf1}, {2, 0xc7},
{1, 0x0e}, {1, 0x3f}, {2, 0xff}, {1, 0xc0}, {2, 0x00}, {1, 0x07}, {1, 0x00}, {1, 0x7f}, {6, 0xff},
{1, 0xf1}, {1, 0xfe}, {1, 0x1f}, {1, 0x00}, {2, 0x3f}, {1, 0xf1}, {2, 0xc7}, {1, 0xfe}, {1, 0x3f},
{2, 0xff}, {1, 0xc0}, {2, 0x00}, {1, 0x0f}, {1, 0x00}, {1, 0x3f}, {6, 0xff}, {1, 0xe1}, {1, 0xf8},
{1, 0x3e}, {1, 0x0c}, {1, 0x1e}, {1, 0x1f}, {1, 0xe3}, {1, 0xc3}, {1, 0x07}, {1, 0xfe}, {1, 0x3f},
{2, 0xff}, {1, 0xc0}, {2, 0x00}, {1, 0x1f}, {1, 0x00}, {1, 0x1f}, {6, 0xff}, {1, 0xe3}, {1, 0xf8},
{1, 0x1e}, {1, 0x3f}, {1, 0x04}, {1, 0x3f}, {1, 0xc3}, {1, 0xe0}, {1, 0x07}, {1, 0xfe}, {1, 0x3f},
{2, 0xff}, {1, 0xc0}, {2, 0x00}, {1, 0x3f}, {1, 0x00}, {1, 0x0f}, {6, 0xff}, {1, 0xc7}, {1, 0xff},
{1, 0x0f}, {1, 0x7f}, {1, 0x80}, {1, 0x7f}, {1, 0xc7}, {1, 0xf0}, {1, 0x47}, {1, 0xfe}, {1, 0x3f},
{2, 0xff}, {1, 0xc0}, {2, 0x00}, {1, 0x7f}, {1, 0x00}, {1, 0x0f}, {6, 0xff}, {1, 0x87}, {1, 0xff},
{1, 0x87}, {1, 0xff}, {1, 0xc0}, {1, 0xff}, {1, 0x87}, {1, 0xff}, {1, 0xc7}, {1, 0xfe}, {1, 0x3f},
{2, 0xff}, {1, 0xc0}, {2, 0x00}, {1, 0x3f}, {1, 0x00}, {1, 0x07}, {6, 0xff}, {1, 0x0f}, {1, 0xff},
{1, 0xc7}, {3, 0xff}, {1, 0x0f}, {1, 0xff}, {1, 0x8f}, {1, 0xfe}, {1, 0x1f}, {2, 0xff}, {1, 0xc7},
{2, 0xe0}, {1, 0x7f}, {1, 0x1c}, {1, 0x07}, {5, 0xff}, {1, 0xfe}, {1, 0x1f}, {1, 0xef}, {1, 0x87},
{2, 0xff}, {1, 0xfe}, {1, 0x1f}, {1, 0xff}, {1, 0x8f}, {1, 0xff}, {1, 0x0f}, {1, 0xbf}, {1, 0xff},
{1, 0xc7}, {1, 0xe1}, {1, 0xf0}, {1, 0x7d}, {1, 0x3e}, {1, 0x03}, {5, 0xff}, {1, 0xfc}, {1, 0x30},
{1, 0xc7}, {1, 0x0f}, {2, 0xff}, {1, 0xfc}, {1, 0x31}, {1, 0xe7}, {1, 0x0f}, {1, 0xff}, {1, 0x07},
{1, 0x1f}, {1, 0xff}, {1, 0xc3}, {1, 0xe1}, {1, 0xf0}, {1, 0x7c}, {1, 0x3e}, {1, 0x03}, {5, 0xff},
{1, 0xf8}, {1, 0x00}, {1, 0xc0}, {1, 0x0f}, {2, 0xff}, {1, 0xf8}, {1, 0x00}, {1, 0xc0}, {1, 0x1f},
{1, 0xff}, {1, 0x80}, {1, 0x1f}, {1, 0xff}, {1, 0xc3}, {1, 0xf1}, {2, 0xf8}, {1, 0x3f}, {1, 0x03},
{5, 0xff}, {1, 0xf8}, {1, 0x00}, {1, 0xe0}, {1, 0x1f}, {2, 0xff}, {1, 0xf8}, {1, 0x00}, {1, 0xe0},
{1, 0x3f}, {1, 0xff}, {1, 0xc0}, {1, 0x3f}, {1, 0xff}, {1, 0xc3}, {1, 0xf3}, {2, 0xf8}, {1, 0x7f},
{1, 0x01}, {7, 0xff}, {1, 0xfc}, {5, 0xff}, {1, 0xf8}, {2, 0xff}, {1, 0xf9}, {2, 0xff}, {1, 0xc1},
{1, 0xf3}, {1, 0xf9}, {1, 0xf8}, {1, 0x7f}, {1, 0x81}, {19, 0xff}, {1, 0xc1}, {1, 0xfb}, {1, 0xfd},
{1, 0xf0}, {1, 0xff}, {1, 0x81}, {19, 0xff}, {1, 0xc1}, {2, 0xff}, {1, 0xf0}, {1, 0xff}, {1, 0xc1},
{19, 0xff}, {1, 0xc0}, {2, 0xff}, {1, 0xed}, {1, 0xff}, {1, 0xc1}, {19, 0xff}, {1, 0xc0}, {1, 0xff},
{1, 0xbf}, {1, 0xe1}, {1, 0xf7}, {1, 0xe1}, {19, 0xff}, {1, 0xc0}, {1, 0xff}, {1, 0x3f}, {1, 0xdb},
{1, 0xf3}, {1, 0xe1}, {19, 0xff}, {1, 0xc0}, {1, 0xff}, {1, 0x3f}, {1, 0xd7}, {1, 0xe3}, {1, 0xf1},
{19, 0xff}, {1, 0xc0}, {1, 0x7f}, {1, 0x1f}, {1, 0xd7}, {1, 0xe1}, {1, 0xf1}, {19, 0xff}, {1, 0xe0},
{1, 0x7e}, {1, 0x1f}, {1, 0x9f}, {1, 0xe1}, {1, 0xf1}, {19, 0xff}, {1, 0xe0}, {1, 0x3e}, {1, 0x1f},
{1, 0x8f}, {1, 0xc3}, {1, 0xe1}, {19, 0xff}, {1, 0xe0}, {1, 0x3e}, {2, 0x0f}, {1, 0xc3}, {1, 0xe1},
{19, 0xff}, {1, 0xe0}, {1, 0x3c}, {2, 0x0f}, {1, 0x87}, {1, 0xc1}, {19, 0xff}, {1, 0xf0}, {1, 0x1c},
{1, 0x06}, {1, 0x07}, {1, 0x87}, {1, 0xc1}, {19, 0xff}, {1, 0xf0}, {3, 0x00}, {1, 0x1f}, {1, 0x81},
{19, 0xff}, {1, 0xf0}, {3, 0x00}, {1, 0x1f}, {1, 0x81}, {19, 0xff}, {1, 0xf8}, {3, 0x00}, {1, 0x1f},
{1, 0x81}, {19, 0xff}, {1, 0xf8}, {3, 0x00}, {1, 0x1f}, {1, 0x81}, {19, 0xff}, {1, 0xfc}, {3, 0x00},
{1, 0x1f}, {1, 0x01}, {19, 0xff}, {1, 0xfe}, {3, 0x00}, {1, 0x1e}, {1, 0x01}, {19, 0xff}, {1, 0xfe},
{3, 0x00}, {1, 0x1c}, {1, 0x01}, {20, 0xff}, {3, 0x00}, {1, 0x10}, {1, 0x01}, {20, 0xff}, {1, 0x80},
{3, 0x00}, {1, 0x01}, {20, 0xff}, {1, 0xc0}, {3, 0x00}, {1, 0x01}, {20, 0xff}, {1, 0xf0}, {3, 0x00},
{1, 0x01}, {20, 0xff}, {1, 0xf8}, {3, 0x00}, {1, 0x01}, {20, 0xff}, {1, 0xfe}, {3, 0x00}, {1, 0x01},
{21, 0xff}, {1, 0xc0}, {2, 0x00}, {1, 0x01}, {21, 0xff}, {1, 0xfc}, {2, 0x00}, {1, 0x01}, {255, 0xff},
{255, 0xff}, {135, 0xff}, {1, 0x83}, {2, 0xff}, {1, 0x00}, {1, 0x7f}, {3, 0xff}, {1, 0x80}, {1, 0x3f},
{1, 0xff}, {1, 0xf0}, {1, 0x0f}, {11, 0xff}, {1, 0xfe}, {1, 0x01}, {1, 0xff}, {1, 0xfc}, {1, 0x00},
{1, 0x1f}, {3, 0xff}, {1, 0x00}, {1, 0x1f}, {1, 0xff}, {1, 0xc0}, {1, 0x03}, {11, 0xff}, {1, 0xf0},
{1, 0x01}, {1, 0xff}, {1, 0xf8}, {1, 0x00}, {1, 0x0f}, {2, 0xff}, {1, 0xfe}, {1, 0x00}, {1, 0x07},
{1, 0xff}, {1, 0x80}, {1, 0x01}, {11, 0xff}, {1, 0xc0}, {1, 0x01}, {1, 0xff}, {1, 0xf0}, {1, 0x00},
{1, 0x07}, {2, 0xff}, {1, 0xfc}, {1, 0x00}, {1, 0x07}, {1, 0xff}, {2, 0x00}, {11, 0xff}, {1, 0xc0},
{1, 0x01}, {1, 0xff}, {1, 0xf0}, {1, 0x1c}, {1, 0x03}, {2, 0xff}, {1, 0xf8}, {1, 0x00}, {1, 0x03},
{1, 0xfe}, {2, 0x00}, {11, 0xff}, {1, 0xc0}, {1, 0x01}, {1, 0xff}, {1, 0xe0}, {1, 0x3f}, {1, 0x03},
{2, 0xff}, {1, 0xf0}, {1, 0x1f}, {1, 0x01}, {1, 0xfe}, {1, 0x03}, {1, 0xc0}, {1, 0x7f}, {10, 0xff},
{1, 0xc0}, {1, 0x01}, {1, 0xff}, {1, 0xe0}, {1, 0x7f}, {1, 0x83}, {2, 0xff}, {1, 0xf0}, {1, 0x3f},
{1, 0x81}, {1, 0xfc}, {1, 0x07}, {1, 0xe0}, {1, 0x7f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xe0},
{1, 0x7f}, {1, 0x81}, {2, 0xff}, {1, 0xf0}, {1, 0x3f}, {1, 0x81}, {1, 0xfc}, {1, 0x0f}, {1, 0xf0},
{1, 0x3f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xe0}, {1, 0x7f}, {1, 0x81}, {1, 0xff}, {1, 0x3f},
{1, 0xe0}, {1, 0x7f}, {1, 0xc0}, {1, 0xfc}, {1, 0x0f}, {1, 0xf0}, {1, 0x3f}, {11, 0xff}, {1, 0x01},
{1, 0xff}, {1, 0xe0}, {1, 0x7f}, {1, 0x83}, {1, 0xfc}, {1, 0x0f}, {1, 0xe0}, {1, 0x7f}, {1, 0xc0},
{1, 0xf8}, {1, 0x0f}, {1, 0xf0}, {1, 0x3f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xe0}, {1, 0x7f},
{1, 0x83}, {1, 0xfc}, {1, 0x07}, {1, 0xe0}, {1, 0x7f}, {1, 0xc0}, {1, 0xf8}, {1, 0x1f}, {1, 0xf0},
{1, 0x1f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xe0}, {1, 0x3f}, {1, 0x83}, {1, 0xf8}, {1, 0x07},
{1, 0xe0}, {1, 0x7f}, {1, 0xc0}, {1, 0xf8}, {1, 0x1f}, {1, 0xf8}, {1, 0x1f}, {11, 0xff}, {1, 0x01},
{1, 0xff}, {1, 0xf0}, {1, 0x1f}, {1, 0x07}, {1, 0xf8}, {1, 0x07}, {1, 0xe0}, {1, 0x7f}, {1, 0xc0},
{1, 0x78}, {1, 0x1f}, {1, 0xf8}, {1, 0x1f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xf8}, {2, 0x07},
{1, 0xf8}, {1, 0x07}, {1, 0xc0}, {1, 0x7f}, {1, 0xc0}, {1, 0x78}, {1, 0x1f}, {1, 0xf8}, {1, 0x1f},
{11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xf8}, {1, 0x00}, {1, 0x0f}, {1, 0xf8}, {1, 0x07}, {1, 0xc0},
{1, 0x7f}, {1, 0xc0}, {1, 0x78}, {1, 0x1f}, {1, 0xf8}, {1, 0x1f}, {11, 0xff}, {1, 0x01}, {1, 0xff},
{1, 0xfc}, {1, 0x00}, {1, 0x1f}, {1, 0xfc}, {1, 0x0f}, {1, 0xc0}, {1, 0x7f}, {1, 0xc0}, {1, 0x78},
{1, 0x1f}, {1, 0xf8}, {1, 0x1f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xfe}, {1, 0x00}, {1, 0x1f},
{1, 0xfe}, {1, 0x1f}, {1, 0xc0}, {1, 0x7f}, {1, 0xe0}, {1, 0x78}, {1, 0x1f}, {1, 0xf8}, {1, 0x1f},
{11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xfc}, {1, 0x00}, {1, 0x0f}, {2, 0xff}, {1, 0xc0}, {1, 0x7f},
{1, 0xe0}, {1, 0x78}, {1, 0x1f}, {1, 0xf8}, {1, 0x1f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xf0},
{1, 0x20}, {1, 0x07}, {2, 0xff}, {1, 0xc0}, {1, 0x7f}, {1, 0xc0}, {1, 0x78}, {1, 0x1f}, {1, 0xf8},
{1, 0x1f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xf0}, {1, 0x78}, {1, 0x03}, {2, 0xff}, {1, 0xc0},
{1, 0x7f}, {1, 0xc0}, {1, 0x78}, {1, 0x1f}, {1, 0xf8}, {1, 0x1f}, {11, 0xff}, {1, 0x01}, {1, 0xff},
{1, 0xe0}, {1, 0xfe}, {1, 0x01}, {2, 0xff}, {1, 0xe0}, {1, 0x7f}, {1, 0xc0}, {1, 0x78}, {1, 0x1f},
{1, 0xf8}, {1, 0x1f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xc0}, {1, 0xff}, {1, 0x01}, {2, 0xff},
{1, 0xe0}, {1, 0x7f}, {1, 0xc0}, {1, 0xf8}, {1, 0x1f}, {1, 0xf8}, {1, 0x1f}, {11, 0xff}, {1, 0x01},
{1, 0xff}, {1, 0xc0}, {1, 0xff}, {1, 0x80}, {2, 0xff}, {1, 0xe0}, {1, 0x7f}, {1, 0xc0}, {1, 0xf8},
{1, 0x1f}, {1, 0xf0}, {1, 0x1f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xc1}, {1, 0xff}, {1, 0xc0},
{2, 0xff}, {1, 0xe0}, {1, 0x7f}, {1, 0xc0}, {1, 0xf8}, {1, 0x1f}, {1, 0xf0}, {1, 0x3f}, {11, 0xff},
{1, 0x01}, {1, 0xff}, {1, 0xc1}, {1, 0xff}, {1, 0xc0}, {2, 0xff}, {1, 0xe0}, {1, 0x7f}, {1, 0xc0},
{1, 0xfc}, {1, 0x0f}, {1, 0xf0}, {1, 0x3f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xc1}, {1, 0xff},
{1, 0xc0}, {1, 0xff}, {1, 0x3f}, {1, 0xf0}, {1, 0x3f}, {1, 0x80}, {1, 0xfc}, {1, 0x0f}, {1, 0xf0},
{1, 0x3f}, {11, 0xff}, {1, 0x01}, {1, 0xff}, {1, 0xc0}, {1, 0xff}, {1, 0x80}, {1, 0xfc}, {1, 0x0f},
{1, 0xf0}, {1, 0x3f}, {1, 0x81}, {1, 0xfc}, {1, 0x0f}, {1, 0xe0}, {1, 0x3f}, {11, 0xff}, {1, 0x01},
{1, 0xff}, {1, 0xc0}, {1, 0x7f}, {1, 0x81}, {1, 0xfc}, {1, 0x07}, {1, 0xf0}, {1, 0x1f}, {1, 0x01},
{1, 0xfe}, {1, 0x07}, {1, 0xe0}, {1, 0x7f}, {10, 0xff}, {1, 0x80}, {1, 0x00}, {1, 0x07}, {1, 0xc0},
{1, 0x3f}, {1, 0x01}, {1, 0xf8}, {1, 0x07}, {1, 0xf8}, {1, 0x0e}, {1, 0x03}, {1, 0xfe}, {1, 0x03},
{1, 0x80}, {1, 0x7f}, {10, 0xff}, {1, 0x80}, {1, 0x00}, {1, 0x07}, {1, 0xe0}, {1, 0x00}, {1, 0x03},
{1, 0xf8}, {1, 0x07}, {1, 0xf8}, {1, 0x00}, {1, 0x03}, {1, 0xff}, {2, 0x00}, {11, 0xff}, {1, 0x80},
{1, 0x00}, {1, 0x07}, {1, 0xf0}, {1, 0x00}, {1, 0x03}, {1, 0xf8}, {1, 0x07}, {1, 0xfc}, {1, 0x00},
{1, 0x07}, {1, 0xff}, {1, 0x00}, {1, 0x01}, {11, 0xff}, {1, 0x80}, {1, 0x00}, {1, 0x07}, {1, 0xf8},
{1, 0x00}, {1, 0x07}, {1, 0xf8}, {1, 0x07}, {1, 0xfe}, {1, 0x00}, {1, 0x0f}, {1, 0xff}, {1, 0x80},
{1, 0x03}, {11, 0xff}, {1, 0x80}, {1, 0x00}, {1, 0x07}, {1, 0xfc}, {1, 0x00}, {1, 0x1f}, {1, 0xfc},
{1, 0x0f}, {1, 0xff}, {1, 0x00}, {1, 0x1f}, {1, 0xff}, {1, 0xe0}, {1, 0x07}, {15, 0xff}, {1, 0x80},
{1, 0xff}, {1, 0xfe}, {1, 0x1f}, {1, 0xff}, {1, 0xe0}, {1, 0x7f}, {1, 0xff}, {1, 0xf8}, {1, 0x1f},
{255, 0xff}, {255, 0xff}, {217, 0xff}, {1, 0xfc}, {4, 0x00}, {1, 0x0f}, {19, 0xff}, {1, 0xf9}, {24, 0xff},
{1, 0xfb}, {24, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0xfa}, {1, 0x1f}, {21, 0xff}, {1, 0xfb}, {1, 0xff},
{1, 0xe1}, {1, 0x1f}, {4, 0xff}, {1, 0xfc}, {7, 0x00}, {1, 0x3f}, {8, 0xff}, {1, 0xfb}, {1, 0xff},
{1, 0xc1}, {1, 0x0f}, {4, 0xff}, {1, 0xf0}, {7, 0x00}, {1, 0x1f}, {8, 0xff}, {1, 0xfb}, {1, 0xff},
{1, 0x81}, {1, 0x8f}, {4, 0xff}, {1, 0xf0}, {7, 0x00}, {1, 0x0f}, {8, 0xff}, {1, 0xfb}, {1, 0xff},
{1, 0x00}, {1, 0x87}, {4, 0xff}, {1, 0xf0}, {7, 0x00}, {1, 0x1f}, {8, 0xff}, {1, 0xfb}, {1, 0xff},
{1, 0x00}, {1, 0x87}, {4, 0xff}, {1, 0xec}, {7, 0x00}, {1, 0x37}, {8, 0xff}, {1, 0xfb}, {1, 0xff},
{1, 0x00}, {1, 0x47}, {4, 0xff}, {1, 0xe7}, {3, 0x00}, {1, 0x3e}, {3, 0x00}, {1, 0xc7}, {8, 0xff},
{1, 0xfb}, {1, 0xfe}, {1, 0x00}, {1, 0x43}, {4, 0xff}, {1, 0xe1}, {1, 0x80}, {2, 0x00}, {1, 0x30},
{2, 0x00}, {1, 0x03}, {1, 0x87}, {2, 0xff}, {1, 0xfe}, {1, 0x00}, {4, 0xff}, {1, 0xfb}, {1, 0xff},
{1, 0x00}, {1, 0x43}, {4, 0xff}, {1, 0xe0}, {1, 0x60}, {2, 0x00}, {1, 0x60}, {2, 0x00}, {1, 0x0e},
{1, 0x07}, {2, 0xff}, {1, 0xf0}, {1, 0x00}, {1, 0x1f}, {3, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0x00},
{1, 0x23}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x38}, {2, 0x00}, {1, 0x6c}, {2, 0x00},
{1, 0x18}, {1, 0x07}, {2, 0xff}, {1, 0xe0}, {1, 0x00}, {1, 0x0f}, {3, 0xff}, {1, 0xfb}, {1, 0xfe},
{1, 0x00}, {1, 0x23}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x0e}, {2, 0x00}, {1, 0x7e},
{2, 0x00}, {1, 0x60}, {1, 0x07}, {2, 0xff}, {1, 0x80}, {1, 0x00}, {1, 0x03}, {3, 0xff}, {1, 0xfb},
{1, 0xff}, {1, 0x00}, {1, 0x13}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x03}, {2, 0x00},
{1, 0x66}, {1, 0x00}, {1, 0x01}, {1, 0xc0}, {1, 0x07}, {2, 0xff}, {2, 0x00}, {1, 0x01}, {3, 0xff},
{1, 0xfb}, {1, 0xff}, {1, 0x00}, {1, 0x17}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x00},
{1, 0xc0}, {1, 0x00}, {1, 0x66}, {1, 0x00}, {1, 0x07}, {1, 0x00}, {1, 0x07}, {2, 0xff}, {2, 0x00},
{1, 0x01}, {3, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0x00}, {1, 0x1f}, {2, 0xff}, {1, 0xfe}, {1, 0xff},
{1, 0xe0}, {1, 0x00}, {1, 0x70}, {1, 0x00}, {1, 0x36}, {1, 0x00}, {1, 0x0c}, {1, 0x00}, {1, 0x07},
{1, 0xff}, {1, 0xfe}, {1, 0x07}, {1, 0x01}, {1, 0xc0}, {3, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0x01},
{3, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x00}, {1, 0x1c}, {1, 0x00}, {1, 0x3c}, {1, 0x00},
{1, 0x30}, {1, 0x00}, {1, 0x07}, {1, 0xff}, {1, 0xfc}, {1, 0x07}, {1, 0x83}, {1, 0xc0}, {1, 0x7f},
{2, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0x01}, {3, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x00},
{1, 0x06}, {3, 0x00}, {1, 0xc0}, {1, 0x00}, {1, 0x07}, {1, 0xff}, {1, 0xfc}, {1, 0x07}, {1, 0x01},
{1, 0xc0}, {1, 0x7f}, {2, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0x80}, {3, 0xff}, {1, 0xfe}, {1, 0xff},
{1, 0xe0}, {1, 0x00}, {1, 0x01}, {1, 0x80}, {1, 0x00}, {1, 0x03}, {1, 0x80}, {1, 0x00}, {1, 0x07},
{1, 0xff}, {1, 0xfc}, {2, 0x00}, {1, 0x07}, {3, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0x80}, {1, 0x7f},
{2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {2, 0x00}, {1, 0x60}, {1, 0x00}, {1, 0x06}, {2, 0x00},
{1, 0x07}, {1, 0xff}, {1, 0xfc}, {2, 0x00}, {1, 0x3c}, {1, 0x1f}, {2, 0xff}, {1, 0xfb}, {1, 0xff},
{1, 0x80}, {1, 0x7f}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {2, 0x00}, {1, 0x38}, {1, 0x00},
{1, 0x18}, {2, 0x00}, {1, 0x07}, {1, 0xff}, {1, 0xfc}, {2, 0x00}, {1, 0x40}, {1, 0x03}, {2, 0xff},
{1, 0xfb}, {1, 0xff}, {1, 0x80}, {1, 0x3f}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {2, 0x00},
{1, 0x0c}, {1, 0x00}, {1, 0x60}, {2, 0x00}, {1, 0x07}, {1, 0xff}, {1, 0xfc}, {1, 0x00}, {1, 0x01},
{1, 0x80}, {1, 0x01}, {2, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0xc0}, {1, 0x3f}, {2, 0xff}, {1, 0xfe},
{1, 0xff}, {1, 0xe0}, {2, 0x00}, {1, 0x33}, {1, 0x01}, {1, 0xf0}, {2, 0x00}, {1, 0x07}, {1, 0xff},
{1, 0xfc}, {1, 0x00}, {1, 0x02}, {2, 0x00}, {1, 0x7f}, {1, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0xc0},
{1, 0x1f}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {2, 0x00}, {1, 0x60}, {1, 0xc3}, {1, 0x0c},
{2, 0x00}, {1, 0x07}, {1, 0xff}, {1, 0xfc}, {1, 0x00}, {1, 0x04}, {2, 0x00}, {1, 0x3f}, {1, 0xff},
{1, 0xfb}, {1, 0xff}, {1, 0xe0}, {1, 0x1f}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x00},
{1, 0x01}, {1, 0x80}, {1, 0x7c}, {1, 0x06}, {2, 0x00}, {1, 0x07}, {1, 0xff}, {1, 0xfc}, {1, 0x00},
{1, 0x04}, {2, 0x00}, {1, 0x3f}, {1, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0xe0}, {1, 0x0f}, {2, 0xff},
{1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x00}, {1, 0x06}, {2, 0x00}, {1, 0x01}, {1, 0x80}, {1, 0x00},
{1, 0x07}, {1, 0xff}, {1, 0xfe}, {1, 0x00}, {1, 0x08}, {1, 0x1c}, {1, 0x18}, {1, 0x1f}, {1, 0xff},
{1, 0xfb}, {1, 0xff}, {1, 0xe0}, {1, 0x0f}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x00},
{1, 0x0c}, {3, 0x00}, {1, 0xc0}, {1, 0x00}, {1, 0x07}, {1, 0xff}, {1, 0xfe}, {1, 0x00}, {1, 0x08},
{1, 0x1c}, {1, 0x18}, {1, 0x1f}, {1, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0xf0}, {1, 0x07}, {2, 0xff},
{1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x00}, {1, 0x30}, {3, 0x00}, {1, 0x30}, {1, 0x00}, {1, 0x07},
{2, 0xff}, {2, 0x00}, {1, 0x08}, {1, 0x00}, {1, 0x1f}, {1, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0xf0},
{1, 0x03}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x00}, {1, 0x60}, {3, 0x00}, {1, 0x0c},
{1, 0x00}, {1, 0x07}, {2, 0xff}, {1, 0x80}, {1, 0x10}, {2, 0x00}, {1, 0x0f}, {1, 0xff}, {1, 0xfb},
{1, 0xff}, {1, 0xf8}, {1, 0x03}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x01}, {1, 0x80},
{3, 0x00}, {1, 0x06}, {1, 0x00}, {1, 0x07}, {2, 0xff}, {1, 0xc0}, {1, 0x10}, {2, 0x00}, {1, 0x1f},
{1, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0xfc}, {1, 0x01}, {2, 0xff}, {1, 0xfe}, {1, 0xff}, {1, 0xe0},
{1, 0x07}, {4, 0x00}, {1, 0x01}, {1, 0x80}, {1, 0x07}, {2, 0xff}, {1, 0xe0}, {1, 0x10}, {2, 0x00},
{1, 0x0f}, {1, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0xfc}, {1, 0x01}, {1, 0xf8}, {1, 0x7f}, {1, 0xfe},
{1, 0xff}, {1, 0xe0}, {1, 0x0c}, {5, 0x00}, {1, 0xc0}, {1, 0x07}, {2, 0xff}, {1, 0xc0}, {1, 0x08},
{2, 0x00}, {1, 0x1f}, {1, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0xfe}, {1, 0x00}, {1, 0xe4}, {1, 0x3f},
{1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x30}, {5, 0x00}, {1, 0x30}, {1, 0x07}, {2, 0xff}, {1, 0xc7},
{1, 0xd8}, {2, 0x00}, {1, 0x1f}, {1, 0xff}, {1, 0xfb}, {1, 0xff}, {1, 0xfe}, {1, 0x00}, {1, 0xc4},
{1, 0x1f}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {1, 0x60}, {5, 0x00}, {1, 0x1c}, {1, 0x07}, {2, 0xff},
{1, 0xdf}, {1, 0xf8}, {2, 0x00}, {1, 0x1f}, {1, 0xff}, {1, 0xfb}, {2, 0xff}, {1, 0x00}, {1, 0x02},
{1, 0x1f}, {1, 0xfe}, {1, 0xff}, {1, 0xe1}, {1, 0x80}, {5, 0x00}, {1, 0x06}, {1, 0x07}, {3, 0xff},
{1, 0xfc}, {2, 0x00}, {1, 0x3f}, {1, 0xff}, {1, 0xfb}, {2, 0xff}, {1, 0x80}, {1, 0x01}, {1, 0x0f},
{1, 0xfe}, {1, 0xff}, {1, 0xe3}, {6, 0x00}, {1, 0x01}, {1, 0x87}, {3, 0xff}, {1, 0xfe}, {2, 0x00},
{1, 0x7f}, {1, 0xff}, {1, 0xfb}, {2, 0xff}, {1, 0xc0}, {1, 0x01}, {1, 0x87}, {1, 0xfe}, {1, 0xff},
{1, 0xec}, {7, 0x00}, {1, 0xc7}, {4, 0xff}, {2, 0x00}, {2, 0xff}, {1, 0xfb}, {2, 0xff}, {1, 0xc0},
{1, 0x00}, {1, 0x87}, {1, 0xfe}, {1, 0xff}, {1, 0xf0}, {7, 0x00}, {1, 0x37}, {4, 0xff}, {1, 0x80},
{1, 0x01}, {2, 0xff}, {1, 0xfb}, {2, 0xff}, {1, 0xe0}, {1, 0x00}, {1, 0x43}, {1, 0xfe}, {1, 0xff},
{1, 0xe0}, {7, 0x00}, {1, 0x1f}, {4, 0xff}, {1, 0xf0}, {1, 0x00}, {2, 0xff}, {1, 0xfb}, {2, 0xff},
{1, 0xf0}, {1, 0x00}, {1, 0x23}, {1, 0xfe}, {1, 0xff}, {1, 0xe0}, {7, 0x00}, {1, 0x07}, {5, 0xff},
{1, 0xfc}, {2, 0xff}, {1, 0xfb}, {2, 0xff}, {1, 0xf8}, {1, 0x00}, {1, 0x31}, {1, 0xfe}, {1, 0xff},
{1, 0xe0}, {7, 0x00}, {1, 0x0f}, {8, 0xff}, {1, 0xfb}, {2, 0xff}, {1, 0xfc}, {1, 0x00}, {1, 0x13},
{1, 0xfe}, {1, 0xff}, {1, 0xf0}, {7, 0x00}, {1, 0x0f}, {8, 0xff}, {1, 0xfb}, {2, 0xff}, {1, 0xfe},
{1, 0x00}, {1, 0x0f}, {1, 0xfe}, {1, 0xff}, {1, 0xf8}, {7, 0x00}, {1, 0x1f}, {8, 0xff}, {1, 0xfb},
{3, 0xff}, {1, 0x00}, {1, 0x0f}, {1, 0xfe}, {1, 0xff}, {1, 0xfc}, {7, 0x00}, {1, 0x7f}, {8, 0xff},
{1, 0xfb}, {3, 0xff}, {1, 0xc0}, {1, 0x1f}, {1, 0xfe}, {18, 0xff}, {1, 0xfb}, {3, 0xff}, {1, 0xe0},
{1, 0x7f}, {1, 0xfe}, {18, 0xff}, {1, 0xf9}, {3, 0xff}, {1, 0xfd}, {1, 0xff}, {1, 0xfc}, {18, 0xff},
{1, 0xfc}, {5, 0x00}, {1, 0x01}, {201, 0xff},
}),
std::to_array<std::pair<std::uint8_t, std::uint8_t>>({
{8, 0xff}, {1, 0xcf}, {24, 0xff}, {1, 0xcf}, {24, 0xff}, {1, 0xcf}, {24, 0xff}, {1, 0xcf}, {24, 0xff},
{1, 0xcf}, {1, 0xff}, {1, 0x9f}, {22, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0x9f}, {22, 0xff}, {1, 0xcf},
{1, 0xff}, {1, 0x9f}, {22, 0xff}, {1, 0xce}, {1, 0x3f}, {1, 0xff}, {1, 0xe7}, {21, 0xff}, {1, 0xcf},
{1, 0x1f}, {1, 0x9f}, {1, 0xcf}, {21, 0xff}, {1, 0xcf}, {1, 0xbc}, {1, 0x03}, {1, 0xcf}, {21, 0xff},
{1, 0xcf}, {1, 0xf8}, {1, 0x00}, {22, 0xff}, {1, 0xcf}, {1, 0xf0}, {1, 0x00}, {1, 0x7f}, {21, 0xff},
{1, 0xcf}, {1, 0xe0}, {1, 0x00}, {1, 0x3f}, {21, 0xff}, {1, 0xcf}, {1, 0xc0}, {1, 0x00}, {1, 0x3f},
{21, 0xff}, {1, 0xcf}, {1, 0xc0}, {1, 0x00}, {1, 0x1f}, {21, 0xff}, {1, 0xcf}, {1, 0xc0}, {1, 0x00},
{1, 0x1f}, {21, 0xff}, {1, 0xc8}, {1, 0x80}, {1, 0x00}, {1, 0x19}, {21, 0xff}, {1, 0xc8}, {1, 0x80},
{1, 0x00}, {1, 0x10}, {21, 0xff}, {1, 0xcf}, {1, 0x80}, {1, 0x00}, {1, 0x1f}, {21, 0xff}, {1, 0xcf},
{1, 0xc0}, {1, 0x00}, {1, 0x1f}, {21, 0xff}, {1, 0xcf}, {1, 0xc0}, {1, 0x00}, {1, 0x3f}, {21, 0xff},
{1, 0xcf}, {1, 0xc0}, {1, 0x00}, {1, 0x3f}, {21, 0xff}, {1, 0xcf}, {1, 0xe0}, {1, 0x00}, {1, 0x7f},
{21, 0xff}, {1, 0xcf}, {1, 0xf0}, {1, 0x00}, {1, 0x7f}, {21, 0xff}, {1, 0xcf}, {1, 0xf8}, {1, 0x01},
{22, 0xff}, {1, 0xcf}, {1, 0xbe}, {1, 0x03}, {1, 0xcf}, {21, 0xff}, {1, 0xcf}, {1, 0x1f}, {1, 0xff},
{1, 0xc7}, {21, 0xff}, {1, 0xcf}, {1, 0x3f}, {1, 0xff}, {1, 0xe7}, {21, 0xff}, {1, 0xcf}, {1, 0xff},
{1, 0x9f}, {22, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0x9f}, {22, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0x9f},
{22, 0xff}, {1, 0xcf}, {24, 0xff}, {1, 0xcf}, {24, 0xff}, {1, 0xcf}, {24, 0xff}, {1, 0xcf}, {24, 0xff},
{1, 0xcf}, {24, 0xff}, {1, 0xcf}, {24, 0xff}, {1, 0xcf}, {24, 0xff}, {1, 0xcf}, {8, 0xff}, {1, 0x87},
{15, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0xfc}, {1, 0x07}, {5, 0xff}, {1, 0x87}, {15, 0xff}, {1, 0xcf},
{1, 0xff}, {1, 0xf0}, {1, 0x03}, {5, 0xff}, {1, 0x87}, {15, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0xf0},
{1, 0x03}, {5, 0xff}, {1, 0x87}, {15, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0xe0}, {1, 0xfb}, {5, 0xff},
{1, 0x87}, {15, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0xe1}, {1, 0xff}, {2, 0xe1}, {1, 0xc2}, {1, 0x0f},
{1, 0xf0}, {1, 0x07}, {1, 0x80}, {1, 0x7c}, {1, 0x7f}, {1, 0x1f}, {11, 0xff}, {1, 0xcf}, {1, 0xff},
{1, 0xe1}, {1, 0xff}, {2, 0xe1}, {1, 0xc0}, {1, 0x07}, {1, 0xc0}, {1, 0x07}, {1, 0x00}, {1, 0x3c},
{1, 0x3e}, {1, 0x1f}, {11, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0xe0}, {1, 0x7f}, {2, 0xe1}, {1, 0xc0},
{1, 0x03}, {1, 0x80}, {1, 0x07}, {1, 0x00}, {1, 0x1c}, {1, 0x3e}, {1, 0x3f}, {11, 0xff}, {1, 0xcf},
{1, 0xff}, {1, 0xf0}, {1, 0x0f}, {2, 0xe1}, {1, 0xc1}, {1, 0xc3}, {2, 0x87}, {1, 0x7e}, {1, 0x1e},
{1, 0x3e}, {1, 0x3f}, {11, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0xf8}, {1, 0x03}, {2, 0xe1}, {1, 0xc1},
{1, 0xc3}, {1, 0x0f}, {1, 0x87}, {1, 0xfe}, {1, 0x1e}, {1, 0x1c}, {1, 0x3f}, {11, 0xff}, {1, 0xcf},
{1, 0xff}, {1, 0xfe}, {1, 0x03}, {2, 0xe1}, {2, 0xc3}, {1, 0x0f}, {1, 0x87}, {1, 0xc0}, {1, 0x1f},
{1, 0x1c}, {1, 0x7f}, {11, 0xff}, {1, 0xcf}, {2, 0xff}, {1, 0xc1}, {2, 0xe1}, {2, 0xc3}, {1, 0x0f},
{1, 0x87}, {1, 0x00}, {1, 0x1f}, {1, 0x1c}, {1, 0x7f}, {11, 0xff}, {1, 0xcf}, {2, 0xff}, {3, 0xe1},
{2, 0xc3}, {1, 0x0f}, {1, 0x86}, {1, 0x0e}, {1, 0x1f}, {1, 0x08}, {12, 0xff}, {1, 0xcf}, {2, 0xff},
{2, 0xe1}, {1, 0xc1}, {2, 0xc3}, {1, 0x0f}, {1, 0x86}, {1, 0x1e}, {1, 0x1f}, {1, 0x88}, {12, 0xff},
{1, 0xcf}, {1, 0xff}, {1, 0xe7}, {1, 0xc1}, {1, 0xe1}, {1, 0xc1}, {2, 0xc3}, {1, 0x07}, {1, 0x06},
{1, 0x1c}, {1, 0x1f}, {1, 0x88}, {12, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0xe0}, {1, 0x03}, {1, 0xe0},
{1, 0x01}, {2, 0xc3}, {1, 0x80}, {1, 0x06}, {1, 0x00}, {1, 0x1f}, {1, 0xc1}, {12, 0xff}, {1, 0xcf},
{1, 0xff}, {1, 0xe0}, {1, 0x07}, {1, 0xf0}, {1, 0x01}, {2, 0xc3}, {1, 0x80}, {1, 0x07}, {1, 0x00},
{1, 0x1f}, {1, 0xc1}, {12, 0xff}, {1, 0xcf}, {1, 0xff}, {1, 0xf0}, {1, 0x1f}, {1, 0xf8}, {1, 0x61},
{2, 0xc3}, {1, 0xe1}, {1, 0x87}, {1, 0x82}, {1, 0x1f}, {1, 0xc3}, {12, 0xff}, {1, 0xcf}, {11, 0xff},
{1, 0xc3}, {12, 0xff}, {1, 0xcf}, {11, 0xff}, {1, 0x87}, {12, 0xff}, {1, 0xcf}, {10, 0xff}, {1, 0xf8},
{1, 0x0f}, {12, 0xff}, {1, 0xcf}, {10, 0xff}, {1, 0xf8}, {1, 0x1f}, {12, 0xff}, {1, 0xcf}, {10, 0xff},
{1, 0xf8}, {1, 0x3f}, {12, 0xff}, {1, 0xcf}, {24, 0xff}, {1, 0xcf}, {24, 0xff}, {1, 0xcf}, {24, 0xff},
{1, 0xcf}, {16, 0xff}, {75, 0x00}, {16, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3},
{24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff},
{1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3},
{1, 0xff}, {1, 0x87}, {1, 0xf0}, {21, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0x83}, {1, 0xf0}, {21, 0xff},
{1, 0xf3}, {1, 0xff}, {1, 0x83}, {1, 0xf0}, {21, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0x83}, {1, 0xe0},
{21, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0x81}, {1, 0xe0}, {1, 0xf8}, {1, 0x0f}, {2, 0x1f}, {17, 0xff},
{1, 0xf3}, {1, 0xff}, {1, 0x81}, {1, 0xe0}, {1, 0xf0}, {1, 0x07}, {2, 0x1f}, {17, 0xff}, {1, 0xf3},
{1, 0xff}, {1, 0x89}, {1, 0xc0}, {1, 0xf1}, {1, 0x87}, {1, 0x0f}, {1, 0x1f}, {17, 0xff}, {1, 0xf3},
{1, 0xff}, {1, 0x88}, {1, 0xc8}, {1, 0xff}, {1, 0xc7}, {1, 0x8e}, {1, 0x3f}, {17, 0xff}, {1, 0xf3},
{1, 0xff}, {2, 0x88}, {1, 0xff}, {1, 0x83}, {1, 0x8e}, {1, 0x3f}, {17, 0xff}, {1, 0xf3}, {1, 0xff},
{1, 0x8c}, {1, 0x88}, {1, 0xf8}, {1, 0x03}, {1, 0xc6}, {1, 0x3f}, {17, 0xff}, {1, 0xf3}, {1, 0xff},
{1, 0x8c}, {1, 0x18}, {1, 0xf0}, {1, 0x43}, {1, 0xc4}, {1, 0x7f}, {17, 0xff}, {1, 0xf3}, {1, 0xff},
{1, 0x8e}, {1, 0x18}, {1, 0xe1}, {1, 0xc3}, {1, 0xc4}, {1, 0x7f}, {17, 0xff}, {1, 0xf3}, {1, 0xff},
{1, 0x8e}, {1, 0x38}, {1, 0xe3}, {1, 0xc3}, {1, 0xe4}, {1, 0x7f}, {17, 0xff}, {1, 0xf3}, {1, 0xff},
{1, 0x8e}, {1, 0x38}, {1, 0xe1}, {1, 0x83}, {1, 0xe0}, {18, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0x8f},
{1, 0x38}, {1, 0xf0}, {1, 0x03}, {1, 0xf0}, {18, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0x8f}, {1, 0xf8},
{1, 0xf0}, {1, 0x23}, {1, 0xf1}, {18, 0xff}, {1, 0xf3}, {3, 0xff}, {1, 0xfc}, {1, 0xff}, {1, 0xf1},
{18, 0xff}, {1, 0xf3}, {5, 0xff}, {1, 0xf1}, {18, 0xff}, {1, 0xf3}, {5, 0xff}, {1, 0xc3}, {18, 0xff},
{1, 0xf3}, {5, 0xff}, {1, 0x83}, {18, 0xff}, {1, 0xf3}, {4, 0xff}, {2, 0x0f}, {18, 0xff}, {1, 0xf3},
{4, 0xff}, {1, 0x0f}, {19, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0x80}, {1, 0x07}, {1, 0x1f}, {1, 0x0f},
{19, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0x80}, {1, 0x07}, {1, 0x1f}, {1, 0x0f}, {19, 0xff}, {1, 0xf3},
{1, 0xff}, {1, 0x80}, {1, 0x07}, {1, 0x1f}, {1, 0x0f}, {19, 0xff}, {1, 0xf3}, {2, 0xff}, {1, 0x84},
{1, 0x03}, {1, 0x18}, {1, 0x7f}, {18, 0xff}, {1, 0xf3}, {2, 0xff}, {1, 0x8c}, {1, 0x03}, {1, 0x00},
{1, 0x3f}, {18, 0xff}, {1, 0xf3}, {2, 0xff}, {1, 0x0c}, {1, 0x03}, {1, 0x00}, {1, 0x1f}, {18, 0xff},
{1, 0xf3}, {2, 0xff}, {2, 0x1f}, {1, 0x0f}, {1, 0x1f}, {18, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0xfe},
{2, 0x1f}, {1, 0x0f}, {1, 0x1f}, {18, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0xfe}, {1, 0x3f}, {1, 0x1f},
{1, 0x0f}, {1, 0x1f}, {18, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0xfc}, {1, 0x3f}, {1, 0x1f}, {1, 0x0f},
{1, 0x1f}, {18, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0xfc}, {1, 0x7e}, {1, 0x1f}, {1, 0x0f}, {1, 0x1f},
{18, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0xf8}, {1, 0x7f}, {1, 0x1f}, {1, 0x0f}, {1, 0x1f}, {18, 0xff},
{1, 0xf3}, {1, 0xff}, {1, 0xf8}, {1, 0xff}, {1, 0x1f}, {1, 0x0f}, {1, 0x1f}, {18, 0xff}, {1, 0xf3},
{1, 0xff}, {1, 0xf0}, {1, 0xff}, {1, 0x03}, {1, 0x0f}, {1, 0x1f}, {18, 0xff}, {1, 0xf3}, {1, 0xff},
{1, 0xf1}, {1, 0xff}, {1, 0x03}, {1, 0x0f}, {1, 0x1f}, {18, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0xe1},
{1, 0xff}, {1, 0xc3}, {1, 0x9f}, {1, 0x1f}, {18, 0xff}, {1, 0xf3}, {1, 0xff}, {1, 0xe3}, {22, 0xff},
{1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3},
{24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff},
{1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3}, {24, 0xff}, {1, 0xf3},
{8, 0xff}, {75, 0x00}, {98, 0xff}, {1, 0x81}, {23, 0xff}, {1, 0xfe}, {1, 0x00}, {1, 0x7f}, {22, 0xff},
{1, 0xfc}, {1, 0x00}, {1, 0x1f}, {22, 0xff}, {1, 0xf8}, {1, 0x00}, {1, 0x0f}, {22, 0xff}, {1, 0xf8},
{1, 0x3e}, {1, 0x0f}, {22, 0xff}, {1, 0xf0}, {1, 0x7f}, {1, 0x07}, {22, 0xff}, {1, 0xf0}, {1, 0x23},
{1, 0x07}, {22, 0xff}, {1, 0xe0}, {1, 0x03}, {1, 0x07}, {22, 0xff}, {1, 0xe0}, {2, 0x07}, {22, 0xff},
{1, 0xe0}, {1, 0x06}, {1, 0x07}, {22, 0xff}, {1, 0xe0}, {1, 0x1c}, {1, 0x07}, {22, 0xff}, {1, 0xf0},
{1, 0x38}, {1, 0x07}, {22, 0xff}, {1, 0xf0}, {1, 0x7f}, {1, 0x07}, {22, 0xff}, {1, 0xf0}, {1, 0x7f},
{1, 0x0f}, {22, 0xff}, {1, 0xf8}, {1, 0x00}, {1, 0x0f}, {22, 0xff}, {1, 0xfc}, {1, 0x00}, {1, 0x1f},
{22, 0xff}, {1, 0xfe}, {1, 0x00}, {1, 0x3f}, {23, 0xff}, {1, 0x81}, {255, 0xff}, {255, 0xff}, {255, 0xff},
{255, 0xff}, {81, 0xff},
}),
}};

1
eink/io Submodule

@ -0,0 +1 @@
Subproject commit 5407e94337257216067d98b86f03bbd898040fca

352
eink/main.cpp Normal file
View File

@ -0,0 +1,352 @@
#include "clock.hpp"
#include <array>
#include <type_traits>
#include <cstdint>
#include <cstring>
#include "eink/eink.hpp"
#include "flash/flash.hpp"
#include "io/io.hpp"
#include "uart/uart.hpp"
#include "image.hpp"
using uart_t = uart::Uart0<uart::Config<115200>>;
REGISTER_UART0_INT_VECTORS(uart_t);
using spi_t = eink::Spi<io::P::C4, io::P::C5, io::P::C3, io::P::C2>;
using eink_t = eink::Eink<200, 200, spi_t, io::P::C1, io::P::C0>;
using eink::Voltage::VSH1;
using eink::Voltage::VSH2;
using eink::Voltage::VSL1;
using eink::Voltage::VSS1;
constexpr auto
ORIGINAL_WAVEFORM_LUT =
flash::Wrapper<eink::Waveform>{
eink::Waveform{
.lut = {{{
{.phaseD = VSH1, .phaseC = VSH1, .phaseB = VSS1, .phaseA = VSH1},
{.phaseD = VSL1, .phaseC = VSL1, .phaseB = VSH1, .phaseA = VSL1},
{.phaseD = VSL1, .phaseC = VSH1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSL1, .phaseC = VSL1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSL1, .phaseC = VSL1, .phaseB = VSH1, .phaseA = VSL1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSH1, .phaseA = VSL1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSH1, .phaseA = VSL1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSH1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSH1},
}},
{{
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSH1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSL1, .phaseB = VSH1, .phaseA = VSL1},
{.phaseD = VSL1, .phaseC = VSH1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSH1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSH1, .phaseA = VSL1},
{.phaseD = VSS1, .phaseC = VSL1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSL1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSL1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
}},
{{
{.phaseD = VSL1, .phaseC = VSL1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSL1, .phaseC = VSL1, .phaseB = VSH1, .phaseA = VSL1},
{.phaseD = VSL1, .phaseC = VSH1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSH1, .phaseC = VSH1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSH1, .phaseA = VSL1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSH2, .phaseC = VSL1, .phaseB = VSL1, .phaseA = VSS1},
{.phaseD = VSH2, .phaseC = VSS1, .phaseB = VSL1, .phaseA = VSL1},
{.phaseD = VSH2, .phaseC = VSH2, .phaseB = VSH2, .phaseA = VSL1},
{.phaseD = VSS1, .phaseC = VSH2, .phaseB = VSH2, .phaseA = VSH2},
}},
{{
{.phaseD = VSL1, .phaseC = VSL1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSL1, .phaseC = VSL1, .phaseB = VSH1, .phaseA = VSL1},
{.phaseD = VSL1, .phaseC = VSH1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSH1, .phaseC = VSH1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSH1, .phaseA = VSL1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSH2, .phaseC = VSL1, .phaseB = VSL1, .phaseA = VSS1},
{.phaseD = VSH2, .phaseC = VSS1, .phaseB = VSL1, .phaseA = VSL1},
{.phaseD = VSH2, .phaseC = VSH2, .phaseB = VSH2, .phaseA = VSL1},
{.phaseD = VSS1, .phaseC = VSH2, .phaseB = VSH2, .phaseA = VSH2},
}},
{{
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSL1, .phaseA = VSH1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
{.phaseD = VSS1, .phaseC = VSS1, .phaseB = VSS1, .phaseA = VSS1},
}}},
.timings =
{
{
.frameCountPhaseA = 32,
.frameCountPhaseB = 16,
.repeatSubPhaseAB = 0,
.frameCountPhaseC = 19,
.frameCountPhaseD = 20,
.repeatSubPhaseCD = 0,
.repeat = 0,
},
{
.frameCountPhaseA = 3,
.frameCountPhaseB = 3,
.repeatSubPhaseAB = 6,
.frameCountPhaseC = 12,
.frameCountPhaseD = 10,
.repeatSubPhaseCD = 0,
.repeat = 0,
},
{
.frameCountPhaseA = 3,
.frameCountPhaseB = 4,
.repeatSubPhaseAB = 0,
.frameCountPhaseC = 3,
.frameCountPhaseD = 4,
.repeatSubPhaseCD = 0,
.repeat = 10,
},
{
.frameCountPhaseA = 3,
.frameCountPhaseB = 3,
.repeatSubPhaseAB = 10,
.frameCountPhaseC = 22,
.frameCountPhaseD = 2,
.repeatSubPhaseCD = 0,
.repeat = 0,
},
{
.frameCountPhaseA = 3,
.frameCountPhaseB = 3,
.repeatSubPhaseAB = 3,
.frameCountPhaseC = 0,
.frameCountPhaseD = 0,
.repeatSubPhaseCD = 0,
.repeat = 0,
},
{
.frameCountPhaseA = 2,
.frameCountPhaseB = 2,
.repeatSubPhaseAB = 3,
.frameCountPhaseC = 5,
.frameCountPhaseD = 5,
.repeatSubPhaseCD = 1,
.repeat = 0,
},
{
.frameCountPhaseA = 22,
.frameCountPhaseB = 20,
.repeatSubPhaseAB = 0,
.frameCountPhaseC = 20,
.frameCountPhaseD = 0,
.repeatSubPhaseCD = 0,
.repeat = 0,
},
{
.frameCountPhaseA = 0,
.frameCountPhaseB = 0,
.repeatSubPhaseAB = 0,
.frameCountPhaseC = 0,
.frameCountPhaseD = 0,
.repeatSubPhaseCD = 0,
.repeat = 0,
},
{
.frameCountPhaseA = 4,
.frameCountPhaseB = 5,
.repeatSubPhaseAB = 0,
.frameCountPhaseC = 3,
.frameCountPhaseD = 40,
.repeatSubPhaseCD = 0,
.repeat = 2,
},
{
.frameCountPhaseA = 2,
.frameCountPhaseB = 3,
.repeatSubPhaseAB = 0,
.frameCountPhaseC = 3,
.frameCountPhaseD = 50,
.repeatSubPhaseCD = 0,
.repeat = 1,
},
{
.frameCountPhaseA = 6,
.frameCountPhaseB = 3,
.repeatSubPhaseAB = 0,
.frameCountPhaseC = 34,
.frameCountPhaseD = 5,
.repeatSubPhaseCD = 0,
.repeat = 0,
},
{
.frameCountPhaseA = 4,
.frameCountPhaseB = 5,
.repeatSubPhaseAB = 0,
.frameCountPhaseC = 5,
.frameCountPhaseD = 1,
.repeatSubPhaseCD = 0,
.repeat = 0,
},
},
.frameRates = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2},
.subPhaseGateStates = {},
}};
static inline consteval auto createFastWaveformLut(const flash::Wrapper<eink::Waveform> &original)
{
auto fastWaveformLut = original.value;
for (auto i = std::size_t{0}; i < std::size(fastWaveformLut.timings) - 1; ++i) {
fastWaveformLut.timings[i].frameCountPhaseA = 0;
fastWaveformLut.timings[i].frameCountPhaseB = 0;
fastWaveformLut.timings[i].repeatSubPhaseAB = 0;
fastWaveformLut.timings[i].frameCountPhaseC = 0;
fastWaveformLut.timings[i].frameCountPhaseD = 0;
fastWaveformLut.timings[i].repeatSubPhaseCD = 0;
fastWaveformLut.timings[i].repeat = 0;
}
fastWaveformLut.timings[11].frameCountPhaseA = 4;
fastWaveformLut.timings[11].frameCountPhaseB = 5;
fastWaveformLut.timings[11].repeatSubPhaseAB = 2;
fastWaveformLut.timings[11].frameCountPhaseC = 5;
fastWaveformLut.timings[11].frameCountPhaseD = 1;
fastWaveformLut.timings[11].repeatSubPhaseCD = 2;
fastWaveformLut.timings[11].repeat = 4;
return flash::Wrapper{fastWaveformLut};
}
constexpr auto FAST_WAVEFORM_LUT = createFastWaveformLut(ORIGINAL_WAVEFORM_LUT);
void dumpOTP(eink_t &einkDisplay, uart_t &serial)
{
constexpr auto printWidth = 16;
auto printedCnt = std::size_t{0};
einkDisplay.dumpOTP([&serial, &printedCnt](const auto &data) {
constexpr auto printAddress = true;
if (printedCnt > 0 && printedCnt % printWidth == 0) {
serial << F("\r\n");
}
if (printAddress && printedCnt % printWidth == 0) {
serial << F("0x");
serial.txNumber<std::size_t, 16, 4>(printedCnt);
serial << F(": ");
}
serial << F("0x");
serial.txNumber<std::remove_cvref_t<decltype(data)>, 16, 2>(data);
serial << F(", ");
++printedCnt;
});
serial << F("\r\n");
}
int main()
{
uart_t serial;
serial.init();
sei();
serial << F("e-Paper demo") << F("\r\n");
auto einkDisplay = eink_t{};
serial << F("e-Paper init") << F("\r\n");
einkDisplay.init();
serial << F("e-Paper dump OTP") << F("\r\n");
dumpOTP(einkDisplay, serial);
serial << F("e-Paper clear") << F("\r\n");
einkDisplay.clear();
serial << F("e-Paper update") << F("\r\n");
einkDisplay.update();
serial << F("e-Paper draw fast") << F("\r\n");
einkDisplay.draw(RLE_IMAGE);
serial << F("e-Paper update") << F("\r\n");
einkDisplay.update(FAST_WAVEFORM_LUT);
serial << F("e-Paper clear") << F("\r\n");
einkDisplay.clear();
serial << F("e-Paper update") << F("\r\n");
einkDisplay.update();
serial << F("e-Paper draw") << F("\r\n");
einkDisplay.draw(RLE_IMAGE);
serial << F("e-Paper update") << F("\r\n");
einkDisplay.update();
serial << F("e-Paper clear") << F("\r\n");
einkDisplay.clear();
serial << F("e-Paper update") << F("\r\n");
einkDisplay.update();
serial << F("e-Paper draw text") << F("\r\n");
const auto startX = 16;
const auto startY = 58;
einkDisplay.drawText({startX, startY}, "B->B: ", eink_t::Color::BLACK, eink_t::Color::WHITE);
einkDisplay.drawText({startX + 6 * 8, startY}, "Black on black", eink_t::Color::BLACK, eink_t::Color::BLACK);
einkDisplay.drawText({startX, startY + 10}, "B->R: ", eink_t::Color::BLACK, eink_t::Color::WHITE);
einkDisplay.drawText({startX + 6 * 8, startY + 10}, "Black on red", eink_t::Color::BLACK, eink_t::Color::RED);
einkDisplay.drawText({startX, startY + 20}, "B->W: ", eink_t::Color::BLACK, eink_t::Color::WHITE);
einkDisplay.drawText({startX + 6 * 8, startY + 20}, "Black on white", eink_t::Color::BLACK, eink_t::Color::WHITE);
einkDisplay.drawText({startX, startY + 30}, "R->B: ", eink_t::Color::BLACK, eink_t::Color::WHITE);
einkDisplay.drawText({startX + 6 * 8, startY + 30}, "Red on black", eink_t::Color::RED, eink_t::Color::BLACK);
einkDisplay.drawText({startX, startY + 40}, "R->R: ", eink_t::Color::BLACK, eink_t::Color::WHITE);
einkDisplay.drawText({startX + 6 * 8, startY + 40}, "Red on red", eink_t::Color::RED, eink_t::Color::RED);
einkDisplay.drawText({startX, startY + 50}, "R->W: ", eink_t::Color::BLACK, eink_t::Color::WHITE);
einkDisplay.drawText({startX + 6 * 8, startY + 50}, "Red on white", eink_t::Color::RED, eink_t::Color::WHITE);
einkDisplay.drawText({startX, startY + 60}, "W->B: ", eink_t::Color::BLACK, eink_t::Color::WHITE);
einkDisplay.drawText({startX + 6 * 8, startY + 60}, "White on black", eink_t::Color::WHITE, eink_t::Color::BLACK);
einkDisplay.drawText({startX, startY + 70}, "W->R: ", eink_t::Color::BLACK, eink_t::Color::WHITE);
einkDisplay.drawText({startX + 6 * 8, startY + 70}, "White on red", eink_t::Color::WHITE, eink_t::Color::RED);
einkDisplay.drawText({startX, startY + 80}, "W->W: ", eink_t::Color::BLACK, eink_t::Color::WHITE);
einkDisplay.drawText({startX + 6 * 8, startY + 80}, "White on white", eink_t::Color::WHITE, eink_t::Color::WHITE);
serial << F("e-Paper update") << F("\r\n");
einkDisplay.update();
einkDisplay.clear();
einkDisplay.drawText({0, 0 * 5 * 8}, "Big", eink_t::Color::BLACK, eink_t::Color::WHITE, 5);
einkDisplay.drawText({0, 1 * 5 * 8}, "scale", eink_t::Color::BLACK, eink_t::Color::WHITE, 5);
einkDisplay.drawText({0, 2 * 5 * 8}, "O.o", eink_t::Color::RED, eink_t::Color::WHITE, 5);
einkDisplay.update();
serial << F("e-Paper sleep") << F("\r\n");
einkDisplay.sleep();
while (true) {
serial << F("e-Paper running") << F("\r\n");
_delay_ms(1000);
}
return 0;
}

1
eink/uart Submodule

@ -0,0 +1 @@
Subproject commit 419b86999db8735728da2536021351611273d643

1
eink/util Submodule

@ -0,0 +1 @@
Subproject commit 62efd1cb26b5e36a49743ac14ac8da25a3f1142c

157
eink_spi.hpp
View File

@ -1,157 +0,0 @@
#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

142
font.hpp
View File

@ -1,142 +0,0 @@
#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

353
otp.hpp
View File

@ -1,353 +0,0 @@
#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