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:00a1cfa25bd6e5ad60261b76b30b1ecf4e31e0d7
Branches Tags
avr:example
avr:master

No commits in common. "master" and "00a1cfa25bd6e5ad60261b76b30b1ecf4e31e0d7" have entirely different histories.
master ... 00a1cfa25b

15 changed files with 389 additions and 1081 deletions
Show Stats Expand all files Collapse all files

15
.gitmodules vendored Normal file
View File

@ -0,0 +1,15 @@
[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/spi"]
path = eink/spi
url = git@git.blackmark.me:avr/spi.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

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 08dd1073af43b65b358257b968852aae8fc77946

291
eink/eink.cppproj Normal file
View File

@ -0,0 +1,291 @@
<?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++-9.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=c11</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 -std=c++17</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=c11</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 debugging experience (-Og)</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++17</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\epd1in54b_V2.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="eink\imagedata.cpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="eink\imagedata.h">
<SubType>compile</SubType>
</Compile>
<Compile Include="flash\flash.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="io\io.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="main.cpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="spi\config.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="spi\hardware.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="spi\spi.hpp">
<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\func.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="util\new.cpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="util\new.hpp">
<SubType>compile</SubType>
</Compile>
<Compile Include="util\type.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="spi" />
<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 6edb2e5a21e0ce58ff2df936caee8b84e240a46b

1
eink/io Submodule

@ -0,0 +1 @@
Subproject commit 80de36ee7ee3e6b0842d5eaee81d54062cb496b2

51
eink/main.cpp Normal file
View File

@ -0,0 +1,51 @@
#include "clock.hpp"
#include "flash/flash.hpp"
#include "io/io.hpp"
#include "spi/spi.hpp"
#include "uart/uart.hpp"
#include "eink/epd1in54b_V2.h"
#include "eink/imagedata.h"
using uart_t = uart::Uart0<>;
REGISTER_UART0_INT_VECTORS(uart_t);
//////////////////////////////////////////////////////////////////////////
int main()
{
using spi_t = spi::Hardware<spi::Config<>>;
uart_t serial;
serial.init();
sei();
serial << F("e-Paper demo") << F("\r\n");
Epd<spi_t> epd;
if (epd.Init() != 0) {
serial << F("e-Paper init failed") << F("\r\n");
serial.flushTx();
_delay_ms(1000);
return 0;
}
serial << F("e-Paper init") << F("\r\n");
serial << F("e-Paper clear") << F("\r\n");
epd.DisplayClear();
serial << F("e-Paper draw") << F("\r\n");
epd.DisplayFrame(IMAGE_BLACK, IMAGE_RED);
serial << F("e-Paper sleep") << F("\r\n");
epd.Sleep();
while (true) {
serial << F("e-Paper running") << F("\r\n");
_delay_ms(1000);
}
return 0;
}

1
eink/spi Submodule

@ -0,0 +1 @@
Subproject commit 70aabc07f64a33b04e3e9ee00627f5c120b1f9ef

1
eink/uart Submodule

@ -0,0 +1 @@
Subproject commit 119de3244588b19b4afb06f33f66f22bb80a89b5

1
eink/util Submodule

@ -0,0 +1 @@
Subproject commit 632ed6cf41c45786c738732d6e10d3d2bf988690

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