|
| 1 | +#include "Adafruit_ACeP.h" |
| 2 | +#include "Adafruit_EPD.h" |
| 3 | + |
| 4 | +#define BUSY_WAIT 500 |
| 5 | + |
| 6 | +// clang-format off |
| 7 | + |
| 8 | +const uint8_t acep_default_init_code[] { |
| 9 | + ACEP_PANEL_SETTING, 2, 0xEF, 0x08, // LUT from OTP |
| 10 | + ACEP_POWER_SETTING, 4, 0x37, 0x00, 0x23, 0x23, // 0x05&0x05? |
| 11 | + ACEP_POWER_OFF_SEQUENCE, 1, 0x00, |
| 12 | + ACEP_BOOSTER_SOFT_START, 3, 0xC7, 0xC7, 0x1D, |
| 13 | + ACEP_PLL, 1, 0x3C, |
| 14 | + ACEP_TSE, 1, 0x00, |
| 15 | + ACEP_CDI, 1, 0x37, |
| 16 | + ACEP_TCON, 1, 0x22, |
| 17 | + ACEP_RESOLUTION, 4, 0x02, 0x58, 0x01, 0xC0, |
| 18 | + ACEP_PWS, 1, 0xAA, |
| 19 | + 0xFE}; |
| 20 | + |
| 21 | +// clang-format on |
| 22 | + |
| 23 | +/**************************************************************************/ |
| 24 | +/*! |
| 25 | + @brief constructor if using external SRAM chip and software SPI |
| 26 | + @param width the width of the display in pixels |
| 27 | + @param height the height of the display in pixels |
| 28 | + @param SID the SID pin to use |
| 29 | + @param SCLK the SCLK pin to use |
| 30 | + @param DC the data/command pin to use |
| 31 | + @param RST the reset pin to use |
| 32 | + @param CS the chip select pin to use |
| 33 | + @param SRCS the SRAM chip select pin to use |
| 34 | + @param MISO the MISO pin to use |
| 35 | + @param BUSY the busy pin to use |
| 36 | +*/ |
| 37 | +/**************************************************************************/ |
| 38 | +Adafruit_ACEP::Adafruit_ACEP(int width, int height, int8_t SID, int8_t SCLK, |
| 39 | + int8_t DC, int8_t RST, int8_t CS, int8_t SRCS, |
| 40 | + int8_t MISO, int8_t BUSY) |
| 41 | + : Adafruit_EPD(width, height, SID, SCLK, DC, RST, CS, SRCS, MISO, BUSY) { |
| 42 | + |
| 43 | + if ((width % 8) != 0) { |
| 44 | + width += 8 - (width % 8); |
| 45 | + } |
| 46 | + buffer1_size = (uint16_t)width * (uint16_t)height / 2; |
| 47 | + buffer2_size = 0; |
| 48 | + |
| 49 | + if (SRCS >= 0) { |
| 50 | + use_sram = true; |
| 51 | + buffer1_addr = 0; |
| 52 | + buffer2_addr = 0; |
| 53 | + } else { |
| 54 | + buffer1 = (uint8_t *)malloc(buffer1_size); |
| 55 | + buffer2 = NULL; |
| 56 | + } |
| 57 | + |
| 58 | + singleByteTxns = true; |
| 59 | +} |
| 60 | + |
| 61 | +// constructor for hardware SPI - we indicate DataCommand, ChipSelect, Reset |
| 62 | + |
| 63 | +/**************************************************************************/ |
| 64 | +/*! |
| 65 | + @brief constructor if using on-chip RAM and hardware SPI |
| 66 | + @param width the width of the display in pixels |
| 67 | + @param height the height of the display in pixels |
| 68 | + @param DC the data/command pin to use |
| 69 | + @param RST the reset pin to use |
| 70 | + @param CS the chip select pin to use |
| 71 | + @param SRCS the SRAM chip select pin to use |
| 72 | + @param BUSY the busy pin to use |
| 73 | +*/ |
| 74 | +/**************************************************************************/ |
| 75 | +Adafruit_ACEP::Adafruit_ACEP(int width, int height, int8_t DC, int8_t RST, |
| 76 | + int8_t CS, int8_t SRCS, int8_t BUSY, SPIClass *spi) |
| 77 | + : Adafruit_EPD(width, height, DC, RST, CS, SRCS, BUSY, spi) { |
| 78 | + |
| 79 | + if ((height % 8) != 0) { |
| 80 | + height += 8 - (height % 8); |
| 81 | + } |
| 82 | + buffer1_size = (uint16_t)width * (uint16_t)height / 2; |
| 83 | + buffer2_size = 0; |
| 84 | + |
| 85 | + if (SRCS >= 0) { |
| 86 | + use_sram = true; |
| 87 | + buffer1_addr = 0; |
| 88 | + buffer2_addr = 0; |
| 89 | + } else { |
| 90 | + buffer1 = (uint8_t *)malloc(buffer1_size); |
| 91 | + buffer2 = buffer1; |
| 92 | + } |
| 93 | + |
| 94 | + singleByteTxns = true; |
| 95 | +} |
| 96 | + |
| 97 | +/**************************************************************************/ |
| 98 | +/*! |
| 99 | + @brief wait for busy signal to end |
| 100 | +*/ |
| 101 | +/**************************************************************************/ |
| 102 | +void Adafruit_ACEP::busy_wait(void) { |
| 103 | + if (_busy_pin >= 0) { |
| 104 | + while (!digitalRead(_busy_pin)) { // wait for busy high |
| 105 | + delay(10); |
| 106 | + } |
| 107 | + } else { |
| 108 | + delay(BUSY_WAIT); |
| 109 | + } |
| 110 | +} |
| 111 | + |
| 112 | +/**************************************************************************/ |
| 113 | +/*! |
| 114 | + @brief begin communication with and set up the display. |
| 115 | + @param reset if true the reset pin will be toggled. |
| 116 | +*/ |
| 117 | +/**************************************************************************/ |
| 118 | +void Adafruit_ACEP::begin(bool reset) { |
| 119 | + Adafruit_EPD::begin(reset); |
| 120 | + |
| 121 | + delay(100); |
| 122 | + powerDown(); |
| 123 | +} |
| 124 | + |
| 125 | +/**************************************************************************/ |
| 126 | +/*! |
| 127 | + @brief signal the display to update |
| 128 | +*/ |
| 129 | +/**************************************************************************/ |
| 130 | +void Adafruit_ACEP::update() { |
| 131 | + uint8_t buf[4]; |
| 132 | + /* |
| 133 | + // clear data |
| 134 | + buf[0] = 0x02; |
| 135 | + buf[1] = 0x58; |
| 136 | + buf[2] = 0x01; |
| 137 | + buf[3] = 0xC0; |
| 138 | + EPD_command(ACEP_RESOLUTION, buf, 4); |
| 139 | + EPD_command(ACEP_DTM); |
| 140 | + for (int i=0; i< 134400/256; i++) { |
| 141 | + uint8_t block[256]; |
| 142 | + memset(block, 0x77, 256); |
| 143 | + EPD_data(block, 256); |
| 144 | + } |
| 145 | + EPD_command(ACEP_POWER_ON); |
| 146 | + busy_wait(); |
| 147 | + EPD_command(ACEP_DISPLAY_REFRESH); |
| 148 | + busy_wait(); |
| 149 | + EPD_command(ACEP_POWER_OFF); |
| 150 | +
|
| 151 | + if (_busy_pin >= 0) { |
| 152 | + while (digitalRead(_busy_pin)) { // wait for busy LOW |
| 153 | + delay(10); |
| 154 | + } |
| 155 | + } else { |
| 156 | + delay(BUSY_WAIT); |
| 157 | + }*/ |
| 158 | + |
| 159 | + // actual data |
| 160 | + // clear data |
| 161 | + buf[0] = 0x02; |
| 162 | + buf[1] = 0x58; |
| 163 | + buf[2] = 0x01; |
| 164 | + buf[3] = 0xC0; |
| 165 | + EPD_command(ACEP_RESOLUTION, buf, 4); |
| 166 | + EPD_command(ACEP_DTM); |
| 167 | + for (int i = 0; i < 134400 / 256; i++) { |
| 168 | + uint8_t block[256]; |
| 169 | + memset(block, ((i % 6) << 4) | (i % 6), 256); |
| 170 | + EPD_data(block, 256); |
| 171 | + } |
| 172 | + EPD_command(ACEP_POWER_ON); |
| 173 | + busy_wait(); |
| 174 | + EPD_command(ACEP_DISPLAY_REFRESH); |
| 175 | + busy_wait(); |
| 176 | + EPD_command(ACEP_POWER_OFF); |
| 177 | +} |
| 178 | + |
| 179 | +/**************************************************************************/ |
| 180 | +/*! |
| 181 | + @brief start up the display |
| 182 | +*/ |
| 183 | +/**************************************************************************/ |
| 184 | +void Adafruit_ACEP::powerUp() { |
| 185 | + uint8_t buf[5]; |
| 186 | + |
| 187 | + hardwareReset(); |
| 188 | + delay(200); |
| 189 | + busy_wait(); |
| 190 | + const uint8_t *init_code = acep_default_init_code; |
| 191 | + |
| 192 | + if (_epd_init_code != NULL) { |
| 193 | + init_code = _epd_init_code; |
| 194 | + } |
| 195 | + EPD_commandList(init_code); |
| 196 | + delay(1000); |
| 197 | + buf[0] = 0x37; |
| 198 | + EPD_command(ACEP_CDI, buf, 1); |
| 199 | +} |
| 200 | + |
| 201 | +/**************************************************************************/ |
| 202 | +/*! |
| 203 | + @brief wind down the display |
| 204 | +*/ |
| 205 | +/**************************************************************************/ |
| 206 | + |
| 207 | +void Adafruit_ACEP::powerDown(void) { |
| 208 | + uint8_t buf[1]; |
| 209 | + |
| 210 | + delay(1000); |
| 211 | + |
| 212 | + // deep sleep |
| 213 | + buf[0] = 0xA5; |
| 214 | + EPD_command(ACEP_DEEP_SLEEP, buf, 1); |
| 215 | + |
| 216 | + delay(100); |
| 217 | +} |
| 218 | + |
| 219 | +/**************************************************************************/ |
| 220 | +/*! |
| 221 | + @brief Send the specific command to start writing to EPD display RAM |
| 222 | + @param index The index for which buffer to write (0 or 1 or tri-color |
| 223 | + displays) Ignored for monochrome displays. |
| 224 | + @returns The byte that is read from SPI at the same time as sending the |
| 225 | + command |
| 226 | +*/ |
| 227 | +/**************************************************************************/ |
| 228 | +uint8_t Adafruit_ACEP::writeRAMCommand(uint8_t index) { |
| 229 | + return EPD_command(ACEP_DTM, false); |
| 230 | +} |
| 231 | + |
| 232 | +/**************************************************************************/ |
| 233 | +/*! |
| 234 | + @brief Some displays require setting the RAM address pointer |
| 235 | + @param x X address counter value |
| 236 | + @param y Y address counter value |
| 237 | +*/ |
| 238 | +/**************************************************************************/ |
| 239 | +void Adafruit_ACEP::setRAMAddress(uint16_t x, uint16_t y) {} |
0 commit comments