colorful!

Author: ladyada

src/Adafruit_EPD.cpp

@@ -290,7 +290,7 @@ void Adafruit_EPD::writeRAMFramebufferToEPD(uint8_t *framebuffer,
   dcHigh();
   // Serial.printf("Writing from RAM location %04x: \n", &framebuffer);
 
-  for (uint16_t i = 0; i < framebuffer_size; i++) {
+  for (uint32_t i = 0; i < framebuffer_size; i++) {
     uint8_t d = framebuffer[i];
     if (invertdata)
       d = ~d;

src/Adafruit_EPD.h

@@ -20,7 +20,7 @@
 #ifndef _ADAFRUIT_EPD_H_
 #define _ADAFRUIT_EPD_H_
 
-#define EPD_DEBUG
+//#define EPD_DEBUG
 
 #define RAMBUFSIZE 64 ///< size of the ram buffer
 
@@ -155,8 +155,8 @@ class Adafruit_EPD : public Adafruit_GFX {
 
   uint8_t layer_colors[EPD_NUM_COLORS];
 
-  uint16_t buffer1_size; ///< size of the primary buffer
-  uint16_t buffer2_size; ///< size of the secondary buffer
+  uint32_t buffer1_size; ///< size of the primary buffer
+  uint32_t buffer2_size; ///< size of the secondary buffer
   uint8_t *buffer1; ///< the pointer to the primary buffer if using on-chip ram
   uint8_t
       *buffer2; ///< the pointer to the secondary buffer if using on-chip ram

src/drivers/Adafruit_ACeP.cpp

@@ -82,7 +82,7 @@ Adafruit_ACEP::Adafruit_ACEP(int width, int height, int8_t DC, int8_t RST,
   if ((height % 8) != 0) {
     height += 8 - (height % 8);
   }
-  buffer1_size = (uint16_t)width * (uint16_t)height / 2;
+  buffer1_size = width * height / 2;
   buffer2_size = 0;
 
   if (SRCS >= 0) {
@@ -99,41 +99,25 @@ Adafruit_ACEP::Adafruit_ACEP(int width, int height, int8_t DC, int8_t RST,
 
 /**************************************************************************/
 /*!
-    @brief wait for busy signal to end
+    @brief clear all data buffers
 */
 /**************************************************************************/
-void Adafruit_ACEP::busy_wait(void) {
-  if (_busy_pin >= 0) {
-    while (!digitalRead(_busy_pin)) { // wait for busy high
-      delay(10);
-    }
+void Adafruit_ACEP::clearBuffer() {
+  if (use_sram) {
+    sram.erase(colorbuffer_addr, buffer1_size, 0x11);
   } else {
-    delay(BUSY_WAIT);
+    memset(color_buffer, 0x11, buffer1_size);
   }
 }
 
 /**************************************************************************/
 /*!
-    @brief begin communication with and set up the display.
-    @param reset if true the reset pin will be toggled.
+    @brief clear all data buffers
 */
 /**************************************************************************/
-void Adafruit_ACEP::begin(bool reset) {
-  Adafruit_EPD::begin(reset);
-
-  delay(100);
-  //powerDown();
-}
-
-/**************************************************************************/
-/*!
-    @brief signal the display to update
-*/
-/**************************************************************************/
-void Adafruit_ACEP::update() {
-  
+void Adafruit_ACEP::deGhost() {
   uint8_t buf[4];
-  /***************** clear data first */
+
   buf[0] = 0x02;
   buf[1] = 0x58;
   buf[2] = 0x01;
@@ -163,27 +147,169 @@ void Adafruit_ACEP::update() {
   } else {
     delay(BUSY_WAIT);
   }
+}
+
+
+/**************************************************************************/
+/*!
+    @brief clear the display twice to remove any spooky ghost images
+*/
+/**************************************************************************/
+void Adafruit_ACEP::clearDisplay() {
+  clearBuffer();
+  display();
+}
 
+/**************************************************************************/
+/*!
+    @brief draw a single pixel on the screen
+        @param x the x axis position
+        @param y the y axis position
+        @param color the color of the pixel
+*/
+/**************************************************************************/
+void Adafruit_ACEP::drawPixel(int16_t x, int16_t y, uint16_t color) {
+  if ((x < 0) || (x >= width()) || (y < 0) || (y >= height()))
+    return;
+
+  uint8_t *pBuf;
+
+  // deal with non-8-bit heights
+  uint16_t _HEIGHT = HEIGHT;
+  if (_HEIGHT % 8 != 0) {
+    _HEIGHT += 8 - (_HEIGHT % 8);
+  }
+
+  // check rotation, move pixel around if necessary
+  switch (getRotation()) {
+  case 1:
+    EPD_swap(x, y);
+    x = WIDTH - x - 1;
+    break;
+  case 2:
+    x = WIDTH - x - 1;
+    y = _HEIGHT - y - 1;
+    break;
+  case 3:
+    EPD_swap(x, y);
+    y = _HEIGHT - y - 1;
+    break;
+  }
+  uint32_t addr = ((uint32_t)x + (uint32_t)y*WIDTH)/2;
+  bool lower_nibble = x % 2;
+  uint8_t color_c;
+
+  if (use_sram) {
+    color_c = sram.read8(colorbuffer_addr + addr);
+    pBuf = &color_c;
+  } else {
+    pBuf = color_buffer + addr;
+  }
+
+  if (lower_nibble) {
+    *pBuf &= 0xF0; // save higher nib
+    *pBuf |= (color & 0xF);
+  } else {
+    *pBuf &= 0x0F; // save lower nib
+    *pBuf |= (color & 0xF) << 4;
+  }
+  
+  if (use_sram) {
+    sram.write8(colorbuffer_addr + addr, *pBuf);
+  }
+}
+
+
+/**************************************************************************/
+/*!
+    @brief wait for busy signal to end
+*/
+/**************************************************************************/
+void Adafruit_ACEP::busy_wait(void) {
+  if (_busy_pin >= 0) {
+    while (!digitalRead(_busy_pin)) { // wait for busy high
+      delay(10);
+    }
+  } else {
+    delay(BUSY_WAIT);
+  }
+}
+
+/**************************************************************************/
+/*!
+    @brief begin communication with and set up the display.
+    @param reset if true the reset pin will be toggled.
+*/
+/**************************************************************************/
+void Adafruit_ACEP::begin(bool reset) {
+  Adafruit_EPD::begin(reset);
+  delay(100);
+}
+
+
+/**************************************************************************/
+/*!
+    @brief Transfer the data stored in the buffer(s) to the display
+*/
+/**************************************************************************/
+void Adafruit_ACEP::display(bool sleep) {
+  uint8_t c;
+
+#ifdef EPD_DEBUG
+  Serial.println("  Powering Up");
+#endif
+
+  powerUp();
+
+#ifdef EPD_DEBUG
+  Serial.println("  De Ghosting");
+#endif
+
+  deGhost();
   delay(500);
 
-  // actual data
-  // setresolution, write data
-  buf[0] = 0x02;
-  buf[1] = 0x58;
-  buf[2] = 0x01;
-  buf[3] = 0xC0;
-  EPD_command(ACEP_RESOLUTION, buf, 4);
-  EPD_command(ACEP_DTM);
 
-  remaining = (600UL * 448UL / 2);
-  while (remaining) {
-    uint8_t block[256];
-    uint32_t numbytes = min(remaining, sizeof(block));
-    memset(block, 0x44, numbytes);
-    EPD_data(block, numbytes);
-    remaining -= numbytes;
+#ifdef EPD_DEBUG
+  Serial.println("  Powering Up");
+#endif
+
+
+  powerUp();
+
+#ifdef EPD_DEBUG
+  Serial.println("  Write frame buffer");
+#endif
+
+  if (use_sram) {
+    writeSRAMFramebufferToEPD(buffer1_addr, buffer1_size, 0);
+  } else {
+    writeRAMFramebufferToEPD(buffer1, buffer1_size, 0);
   }
 
+#ifdef EPD_DEBUG
+  Serial.println("  Update");
+#endif
+  update();
+  partialsSinceLastFullUpdate = 0;
+
+  if (sleep) {
+#ifdef EPD_DEBUG
+    Serial.println("  Powering Down");
+#endif
+    powerDown();
+  }
+}
+
+
+/**************************************************************************/
+/*!
+    @brief signal the display to update
+*/
+/**************************************************************************/
+void Adafruit_ACEP::update(void) {
+  
+  uint8_t buf[4];
+
   EPD_command(ACEP_POWER_ON);
   busy_wait();
   EPD_command(ACEP_DISPLAY_REFRESH);
@@ -215,6 +341,14 @@ void Adafruit_ACEP::powerUp() {
     init_code = _epd_init_code;
   }
   EPD_commandList(init_code);
+
+  // set resolution
+  buf[0] = 0x02;
+  buf[1] = 0x58;
+  buf[2] = 0x01;
+  buf[3] = 0xC0;
+  EPD_command(ACEP_RESOLUTION, buf, 4);
+
   delay(100);
 }
 

src/drivers/Adafruit_ACeP.h

@@ -20,6 +20,15 @@
 #define ACEP_RESOLUTION 0x61
 #define ACEP_PWS 0xE3
 
+#define ACEP_COLOR_BLACK   0x0	/// 000
+#define ACEP_COLOR_WHITE   0x1	///	001
+#define ACEP_COLOR_GREEN   0x2	///	010
+#define ACEP_COLOR_BLUE    0x3	///	011
+#define ACEP_COLOR_RED     0x4	///	100
+#define ACEP_COLOR_YELLOW  0x5	///	101
+#define ACEP_COLOR_ORANGE  0x6	///	110
+
+
 /**************************************************************************/
 /*!
     @brief  Class for interfacing with ACEP EPD drivers
@@ -37,6 +46,13 @@ class Adafruit_ACEP : public Adafruit_EPD {
   void powerUp();
   void powerDown();
   void update();
+  void display(bool sleep=true);
+
+  void clearBuffer();
+  void clearDisplay();
+  void deGhost();
+  void drawPixel(int16_t x, int16_t y, uint16_t color);
+
 
 protected:
   uint8_t writeRAMCommand(uint8_t index);