414 lines
10 KiB
C++
414 lines
10 KiB
C++
#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 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;
|
|
const auto screenPosX = getXScreenCoordinates(posX);
|
|
setRamRange({screenPosX, screenPosX}, {pos.second, pos.second + 7});
|
|
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);
|
|
sendData(dataByte);
|
|
}
|
|
}
|
|
};
|
|
|
|
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
|