diff --git a/adafruit_epd/jd79661.py b/adafruit_epd/jd79661.py new file mode 100644 index 0000000..db9012f --- /dev/null +++ b/adafruit_epd/jd79661.py @@ -0,0 +1,467 @@ +# SPDX-FileCopyrightText: 2025 Liz Clark for Adafruit Industries +# +# SPDX-License-Identifier: MIT + +""" +`adafruit_epd.jd79661` - Adafruit JD79661 - quad-color ePaper display driver +==================================================================================== +CircuitPython driver for Adafruit JD79661 quad-color display breakouts +* Author(s): Liz Clark +""" + +import time + +import adafruit_framebuf +from micropython import const + +from adafruit_epd.epd import Adafruit_EPD + +try: + """Needed for type annotations""" + import typing + + from busio import SPI + from circuitpython_typing.pil import Image + from digitalio import DigitalInOut + from typing_extensions import Literal + +except ImportError: + pass + +__version__ = "0.0.0+auto.0" +__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_EPD.git" + +# Command constants +_JD79661_PANEL_SETTING = const(0x00) +_JD79661_POWER_SETTING = const(0x01) +_JD79661_POWER_OFF = const(0x02) +_JD79661_POWER_ON = const(0x04) +_JD79661_BOOSTER_SOFTSTART = const(0x06) +_JD79661_DEEP_SLEEP = const(0x07) +_JD79661_DATA_START_XMIT = const(0x10) +_JD79661_DISPLAY_REFRESH = const(0x12) +_JD79661_PLL_CONTROL = const(0x30) +_JD79661_CDI = const(0x50) +_JD79661_RESOLUTION = const(0x61) + +# Color constants for internal use (2-bit values) +_JD79661_BLACK = const(0b00) +_JD79661_WHITE = const(0b01) +_JD79661_YELLOW = const(0b10) +_JD79661_RED = const(0b11) + +# Other command constants from init sequence +_JD79661_POFS = const(0x03) +_JD79661_TCON = const(0x60) +_JD79661_CMD_E7 = const(0xE7) +_JD79661_CMD_E3 = const(0xE3) +_JD79661_CMD_B4 = const(0xB4) +_JD79661_CMD_B5 = const(0xB5) +_JD79661_CMD_E9 = const(0xE9) +_JD79661_CMD_4D = const(0x4D) + + +class Adafruit_JD79661(Adafruit_EPD): + """Driver for the JD79661 quad-color ePaper display breakouts""" + + BLACK = const(0) # 0b00 in the display buffer + WHITE = const(1) # 0b01 in the display buffer + YELLOW = const(2) # 0b10 in the display buffer + RED = const(3) # 0b11 in the display buffer + + def __init__( + self, + width: int, + height: int, + spi: SPI, + *, + cs_pin: DigitalInOut, + dc_pin: DigitalInOut, + sramcs_pin: DigitalInOut, + rst_pin: DigitalInOut, + busy_pin: DigitalInOut, + ) -> None: + """Initialize the quad-color display driver. + + Note: This driver uses a different buffer architecture than the parent class. + Instead of separate black and color buffers, it uses a single buffer with + 2 bits per pixel to represent 4 colors. + """ + super().__init__(width, height, spi, cs_pin, dc_pin, sramcs_pin, rst_pin, busy_pin) + + stride = width + if stride % 8 != 0: + stride += 8 - stride % 8 + + self._buffer1_size = int(stride * height / 4) + self._buffer2_size = 0 # No second buffer for this display + + if sramcs_pin: + self._buffer1 = self.sram.get_view(0) + self._buffer2 = self._buffer1 + else: + self._buffer1 = bytearray(self._buffer1_size) + self._buffer2 = self._buffer1 + + self._framebuf1 = adafruit_framebuf.FrameBuffer( + self._buffer1, + width, + height, + stride=stride, + buf_format=adafruit_framebuf.MHMSB, + ) + self._framebuf2 = self._framebuf1 # Same framebuffer for compatibility + + # Set single byte transactions + self._single_byte_tx = True + + # Set up buffer references for parent class compatibility + # Both point to the same buffer since we don't have separate color planes + self.set_black_buffer(0, False) + self.set_color_buffer(0, False) + + # Initialize with default fill + self.fill(Adafruit_JD79661.WHITE) + + def begin(self, reset: bool = True) -> None: + """Begin communication with the display and set basic settings""" + if reset: + self.hardware_reset() + time.sleep(0.1) + self.power_down() + + def busy_wait(self) -> None: + """Wait for display to be done with current task, either by polling the + busy pin, or pausing. Note: JD79661 busy is HIGH when busy""" + if self._busy: + while not self._busy.value: # Wait for busy HIGH + time.sleep(0.01) + else: + time.sleep(0.5) + + def power_up(self) -> None: + """Power up the display in preparation for writing RAM and updating""" + self.hardware_reset() + self.busy_wait() + + # Send initialization sequence + time.sleep(0.01) # Wait 10ms + + self.command(_JD79661_CMD_4D, bytearray([0x78])) + self.command( + _JD79661_PANEL_SETTING, bytearray([0x8F, 0x29]) + ) # PSR, Display resolution is 128x250 + self.command(_JD79661_POWER_SETTING, bytearray([0x07, 0x00])) # PWR + self.command(_JD79661_POFS, bytearray([0x10, 0x54, 0x44])) # POFS + self.command( + _JD79661_BOOSTER_SOFTSTART, bytearray([0x05, 0x00, 0x3F, 0x0A, 0x25, 0x12, 0x1A]) + ) + self.command(_JD79661_CDI, bytearray([0x37])) # CDI + self.command(_JD79661_TCON, bytearray([0x02, 0x02])) # TCON + self.command(_JD79661_RESOLUTION, bytearray([0, 128, 0, 250])) # TRES + self.command(_JD79661_CMD_E7, bytearray([0x1C])) + self.command(_JD79661_CMD_E3, bytearray([0x22])) + self.command(_JD79661_CMD_B4, bytearray([0xD0])) + self.command(_JD79661_CMD_B5, bytearray([0x03])) + self.command(_JD79661_CMD_E9, bytearray([0x01])) + self.command(_JD79661_PLL_CONTROL, bytearray([0x08])) + self.command(_JD79661_POWER_ON) + + self.busy_wait() + + def power_down(self) -> None: + """Power down the display - required when not actively displaying!""" + if self._rst: + self.command(_JD79661_POWER_OFF, bytearray([0x00])) + self.busy_wait() + self.command(_JD79661_DEEP_SLEEP, bytearray([0xA5])) + time.sleep(0.1) + + def update(self) -> None: + """Update the display from internal memory""" + self.command(_JD79661_DISPLAY_REFRESH, bytearray([0x00])) + self.busy_wait() + if not self._busy: + time.sleep(1) # Wait 1 second if no busy pin + + def write_ram(self, index: Literal[0, 1]) -> int: + """Send the one byte command for starting the RAM write process.""" + # JD79661 uses same command for all data + return self.command(_JD79661_DATA_START_XMIT, end=False) + + def set_ram_address(self, x: int, y: int) -> None: + """Set the RAM address location.""" + # Not used for JD79661 + pass + + def fill(self, color: int) -> None: + """Fill the entire display with the specified color. + + Args: + color: Color value (BLACK, WHITE, YELLOW, or RED) + + Raises: + ValueError: If an invalid color is specified + """ + # Map colors to fill patterns (4 pixels per byte) + color_map = { + Adafruit_JD79661.BLACK: 0x00, # 0b00000000 - all pixels black + Adafruit_JD79661.WHITE: 0x55, # 0b01010101 - all pixels white + Adafruit_JD79661.YELLOW: 0xAA, # 0b10101010 - all pixels yellow + Adafruit_JD79661.RED: 0xFF, # 0b11111111 - all pixels red + } + + if color not in color_map: + raise ValueError( + f"Invalid color: {color}. Use BLACK (0), WHITE (1), YELLOW (2), or RED (3)." + ) + + fill_byte = color_map[color] + + if self.sram: + self.sram.erase(0x00, self._buffer1_size, fill_byte) + else: + for i in range(self._buffer1_size): + self._buffer1[i] = fill_byte + + def pixel(self, x: int, y: int, color: int) -> None: + """Draw a single pixel in the display buffer. + + Args: + x: X coordinate + y: Y coordinate + color: Color value (BLACK, WHITE, YELLOW, or RED) + """ + if (x < 0) or (x >= self.width) or (y < 0) or (y >= self.height): + return + + # Handle rotation + if self.rotation == 1: + x, y = y, x + x = self._width - x - 1 + if self._width % 8 != 0: + x -= self._width % 8 + elif self.rotation == 2: + x = self._width - x - 1 + y = self._height - y - 1 + if self._width % 8 != 0: + x += self._width % 8 + elif self.rotation == 3: + x, y = y, x + y = self._height - y - 1 + + # Calculate stride (width adjusted to be divisible by 8) + stride = self._width + if stride % 8 != 0: + stride += 8 - stride % 8 + + # Map color constants to 2-bit values + color_map = { + Adafruit_JD79661.BLACK: _JD79661_BLACK, + Adafruit_JD79661.WHITE: _JD79661_WHITE, + Adafruit_JD79661.YELLOW: _JD79661_YELLOW, + Adafruit_JD79661.RED: _JD79661_RED, + } + + if color not in color_map: + # Default to white for invalid colors + pixel_color = _JD79661_WHITE + else: + pixel_color = color_map[color] + + # Calculate byte address (4 pixels per byte) + addr = (x + y * stride) // 4 + + # Calculate bit offset within byte (2 bits per pixel) + # Pixels are packed left-to-right, MSB first + bit_offset = (3 - (x % 4)) * 2 + + # Create masks + byte_mask = 0x3 << bit_offset + byte_value = (pixel_color & 0x3) << bit_offset + + # Read, modify, write + if self.sram: + current = self.sram.read8(addr) + current &= ~byte_mask + current |= byte_value + self.sram.write8(addr, current) + else: + self._buffer1[addr] &= ~byte_mask + self._buffer1[addr] |= byte_value + + def rect(self, x: int, y: int, width: int, height: int, color: int) -> None: + """Draw a rectangle. + + Overridden to use the quad-color pixel method. + """ + for i in range(x, x + width): + self.pixel(i, y, color) + self.pixel(i, y + height - 1, color) + for j in range(y + 1, y + height - 1): + self.pixel(x, j, color) + self.pixel(x + width - 1, j, color) + + def fill_rect(self, x: int, y: int, width: int, height: int, color: int) -> None: + """Fill a rectangle with the passed color. + + Overridden to use the quad-color pixel method. + """ + for i in range(x, x + width): + for j in range(y, y + height): + self.pixel(i, j, color) + + def line(self, x_0: int, y_0: int, x_1: int, y_1: int, color: int) -> None: + """Draw a line from (x_0, y_0) to (x_1, y_1) in passed color. + + Overridden to use the quad-color pixel method. + """ + dx = abs(x_1 - x_0) + dy = abs(y_1 - y_0) + sx = 1 if x_0 < x_1 else -1 + sy = 1 if y_0 < y_1 else -1 + err = dx - dy + + while True: + self.pixel(x_0, y_0, color) + if x_0 == x_1 and y_0 == y_1: + break + e2 = 2 * err + if e2 > -dy: + err -= dy + x_0 += sx + if e2 < dx: + err += dx + y_0 += sy + + def text( + self, + string: str, + x: int, + y: int, + color: int, + *, + font_name: str = "font5x8.bin", + size: int = 1, + ) -> None: + """Write text string at location (x, y) in given color, using font file.""" + color_map = { + Adafruit_JD79661.BLACK: _JD79661_BLACK, + Adafruit_JD79661.WHITE: _JD79661_WHITE, + Adafruit_JD79661.YELLOW: _JD79661_YELLOW, + Adafruit_JD79661.RED: _JD79661_RED, + } + if color not in color_map: + raise ValueError( + f"Invalid color: {color}. Use BLACK (0), WHITE (1), YELLOW (2), or RED (3)." + ) + + text_width = len(string) * 6 * size + text_height = 8 * size + + text_width = min(text_width, self.width - x) + text_height = min(text_height, self.height - y) + + if text_width <= 0 or text_height <= 0: + return + + temp_buf_width = ((text_width + 7) // 8) * 8 + temp_buf = bytearray((temp_buf_width * text_height) // 8) + + temp_fb = adafruit_framebuf.FrameBuffer( + temp_buf, temp_buf_width, text_height, buf_format=adafruit_framebuf.MHMSB + ) + + temp_fb.fill(0) + temp_fb.text(string, 0, 0, 1, font_name=font_name, size=size) + + for j in range(text_height): + for i in range(text_width): + byte_index = (j * temp_buf_width + i) // 8 + bit_index = 7 - ((j * temp_buf_width + i) % 8) + + if byte_index < len(temp_buf): + if (temp_buf[byte_index] >> bit_index) & 1: + self.pixel(x + i, y + j, color) + + def image(self, image: Image) -> None: + """Set buffer to value of Python Imaging Library image. The image should + be in RGB mode and a size equal to the display size. + """ + imwidth, imheight = image.size + if imwidth != self.width or imheight != self.height: + raise ValueError( + f"Image must be same dimensions as display ({self.width}x{self.height})." + ) + if self.sram: + raise RuntimeError("PIL image is not for use with SRAM assist") + + # Grab all the pixels from the image, faster than getpixel. + pix = image.load() + + # Clear out any display buffers (assuming white background) + self.fill(Adafruit_JD79661.WHITE) + + if image.mode == "RGB": # RGB Mode + for y in range(image.size[1]): + for x in range(image.size[0]): + pixel = pix[x, y] + r, g, b = pixel[0], pixel[1], pixel[2] + + # Calculate brightness/luminance for better color detection + brightness = (r + g + b) / 3 + + # Color detection logic with thresholds + if brightness >= 200: # Light colors -> White + # White is typically the default, so we might not need to set it + # self.pixel(x, y, Adafruit_EPD.WHITE) + pass + elif r >= 128 and g >= 128 and b < 80: # Yellow detection + # High red and green, low blue + self.pixel(x, y, Adafruit_JD79661.YELLOW) + elif r >= 128 and g < 80 and b < 80: # Red detection + # High red, low green and blue + self.pixel(x, y, Adafruit_JD79661.RED) + elif brightness < 80: # Dark colors -> Black + # All RGB values are low + self.pixel(x, y, Adafruit_JD79661.BLACK) + elif r > g and r > b and r >= 100: + # Red-dominant + self.pixel(x, y, Adafruit_JD79661.RED) + elif r >= 100 and g >= 100: + # Both red and green high -> Yellow + self.pixel(x, y, Adafruit_JD79661.YELLOW) + elif brightness < 128: + # Medium-dark -> Black + self.pixel(x, y, Adafruit_JD79661.BLACK) + # else: remains white (default) + + elif image.mode == "L": # Grayscale Mode + for y in range(image.size[1]): + for x in range(image.size[0]): + pixel = pix[x, y] + + # Map grayscale to 4 levels + if pixel < 64: + self.pixel(x, y, Adafruit_JD79661.BLACK) + elif pixel < 128: + self.pixel(x, y, Adafruit_JD79661.RED) # Or could use YELLOW + elif pixel < 192: + self.pixel(x, y, Adafruit_JD79661.YELLOW) + # else: pixel >= 192 -> WHITE (default) + + elif image.mode == "P": # Palette Mode (optional, for indexed color) + # Convert to RGB first for easier processing + rgb_image = image.convert("RGB") + self.image(rgb_image) # Recursive call with RGB image + + else: + raise ValueError("Image must be in mode RGB, L, or P.") + + def set_black_buffer(self, index: Literal[0, 1], inverted: bool) -> None: + """Set the index for the black buffer data.""" + super().set_black_buffer(index, inverted) + + def set_color_buffer(self, index: Literal[0, 1], inverted: bool) -> None: + """Set the index for the color buffer data.""" + super().set_color_buffer(index, inverted) diff --git a/examples/epd_blinka.py b/examples/epd_blinka.py index cb91569..c950e4d 100644 --- a/examples/epd_blinka.py +++ b/examples/epd_blinka.py @@ -11,6 +11,7 @@ from adafruit_epd.il0373 import Adafruit_IL0373 from adafruit_epd.il0398 import Adafruit_IL0398 from adafruit_epd.il91874 import Adafruit_IL91874 +from adafruit_epd.jd79661 import Adafruit_JD79661 from adafruit_epd.ssd1608 import Adafruit_SSD1608 from adafruit_epd.ssd1675 import Adafruit_SSD1675 from adafruit_epd.ssd1675b import Adafruit_SSD1675B @@ -18,9 +19,6 @@ from adafruit_epd.ssd1681 import Adafruit_SSD1681 from adafruit_epd.uc8151d import Adafruit_UC8151D -# create the spi device and pins we will need -spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) - # create the spi device and pins we will need spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO) ecs = digitalio.DigitalInOut(board.D4) @@ -32,6 +30,7 @@ # give them all to our driver print("Creating display") +# display = Adafruit_JD79661(122, 150, # 2.13" Quad-color display # display = Adafruit_SSD1608(200, 200, # 1.54" HD mono display # display = Adafruit_SSD1680(122, 250, # 2.13" HD Tri-color display # display = Adafruit_SSD1681(200, 200, # 1.54" HD Tri-color display @@ -70,6 +69,7 @@ image = Image.new("RGB", (width, height)) WHITE = (0xFF, 0xFF, 0xFF) +YELLOW = (0xFF, 0xFF, 0x00) RED = (0xFF, 0x00, 0x00) BLACK = (0x00, 0x00, 0x00) @@ -118,9 +118,15 @@ # Some other nice fonts to try: http://www.dafont.com/bitmap.php # font = ImageFont.truetype('Minecraftia.ttf', 8) +if type(display) == Adafruit_JD79661: + # for quad color, test yellow + fill = YELLOW +else: + # otherwise, text is red + fill = RED # Write two lines of text. -draw.text((x, top), "Hello", font=font, fill=RED) -draw.text((x, top + 20), "World!", font=font, fill=RED) +draw.text((x, top), "Hello", font=font, fill=fill) +draw.text((x, top + 20), "World!", font=font, fill=fill) # Display image. display.image(image) diff --git a/examples/epd_pillow_demo.py b/examples/epd_pillow_demo.py index 7dcea7a..11dfb3a 100644 --- a/examples/epd_pillow_demo.py +++ b/examples/epd_pillow_demo.py @@ -15,6 +15,7 @@ from adafruit_epd.il0373 import Adafruit_IL0373 from adafruit_epd.il0398 import Adafruit_IL0398 from adafruit_epd.il91874 import Adafruit_IL91874 +from adafruit_epd.jd79661 import Adafruit_JD79661 from adafruit_epd.ssd1608 import Adafruit_SSD1608 from adafruit_epd.ssd1675 import Adafruit_SSD1675 from adafruit_epd.ssd1680 import Adafruit_SSD1680, Adafruit_SSD1680Z @@ -42,6 +43,7 @@ busy = digitalio.DigitalInOut(board.D17) # give them all to our driver +# display = Adafruit_JD79661(122, 150, # 2.13" Quad-color display # display = Adafruit_SSD1608(200, 200, # 1.54" HD mono display # display = Adafruit_SSD1675(122, 250, # 2.13" HD mono display # display = Adafruit_SSD1680(122, 250, # 2.13" HD Tri-color or mono display diff --git a/examples/epd_pillow_image.py b/examples/epd_pillow_image.py index 02238ef..cf96d27 100644 --- a/examples/epd_pillow_image.py +++ b/examples/epd_pillow_image.py @@ -17,6 +17,7 @@ from adafruit_epd.il0373 import Adafruit_IL0373 from adafruit_epd.il0398 import Adafruit_IL0398 from adafruit_epd.il91874 import Adafruit_IL91874 +from adafruit_epd.jd79661 import Adafruit_JD79661 from adafruit_epd.ssd1608 import Adafruit_SSD1608 from adafruit_epd.ssd1675 import Adafruit_SSD1675 from adafruit_epd.ssd1680 import Adafruit_SSD1680, Adafruit_SSD1680Z @@ -32,6 +33,7 @@ busy = digitalio.DigitalInOut(board.D17) # give them all to our driver +# display = Adafruit_JD79661(122, 150, # 2.13" Quad-color display # display = Adafruit_SSD1608(200, 200, # 1.54" HD mono display # display = Adafruit_SSD1675(122, 250, # 2.13" HD mono display # display = Adafruit_SSD1680(122, 250, # 2.13" HD Tri-color or mono display @@ -86,6 +88,38 @@ # Convert to Monochrome and Add dithering # image = image.convert("1").convert("L") +if type(display) == Adafruit_JD79661: + # Create a palette with the 4 colors: Black, White, Red, Yellow + # The palette needs 768 values (256 colors × 3 channels) + palette = [] + + # We'll map the 256 palette indices to our 4 colors + # 0-63: Black, 64-127: Red, 128-191: Yellow, 192-255: White + for i in range(256): + if i < 64: + palette.extend([0, 0, 0]) # Black + elif i < 128: + palette.extend([255, 0, 0]) # Red + elif i < 192: + palette.extend([255, 255, 0]) # Yellow + else: + palette.extend([255, 255, 255]) # White + + # Create a palette image + palette_img = Image.new("P", (1, 1)) + palette_img.putpalette(palette) + + # Optional: Enhance colors before dithering for better results + # from PIL import ImageEnhance + # enhancer = ImageEnhance.Color(image) + # image = enhancer.enhance(1.5) # Increase color saturation + + # Quantize the image using Floyd-Steinberg dithering + image = image.quantize(palette=palette_img, dither=Image.FLOYDSTEINBERG) + + # Convert back to RGB for the display driver + image = image.convert("RGB") + # Display image. display.image(image) display.display() diff --git a/examples/epd_simpletest.py b/examples/epd_simpletest.py index 63c0a29..b8d311e 100644 --- a/examples/epd_simpletest.py +++ b/examples/epd_simpletest.py @@ -10,6 +10,7 @@ from adafruit_epd.il0373 import Adafruit_IL0373 from adafruit_epd.il0398 import Adafruit_IL0398 from adafruit_epd.il91874 import Adafruit_IL91874 +from adafruit_epd.jd79661 import Adafruit_JD79661 from adafruit_epd.ssd1608 import Adafruit_SSD1608 from adafruit_epd.ssd1675 import Adafruit_SSD1675 from adafruit_epd.ssd1680 import Adafruit_SSD1680, Adafruit_SSD1680Z @@ -26,6 +27,7 @@ # give them all to our drivers print("Creating display") +# display = Adafruit_JD79661(122, 150, # 2.13" Quad-color display # display = Adafruit_SSD1608(200, 200, # 1.54" HD mono display # display = Adafruit_SSD1675(122, 250, # 2.13" HD mono display # display = Adafruit_SSD1680(122, 250, # 2.13" HD Tri-color display @@ -58,20 +60,33 @@ # display.set_color_buffer(1, True) display.rotation = 1 +if type(display) == Adafruit_JD79661: + WHITE = Adafruit_JD79661.WHITE + BLACK = Adafruit_JD79661.BLACK + RED = Adafruit_JD79661.RED + YELLOW = Adafruit_JD79661.YELLOW +else: + WHITE = Adafruit_EPD.WHITE + BLACK = Adafruit_EPD.BLACK + RED = Adafruit_EPD.RED # clear the buffer print("Clear buffer") -display.fill(Adafruit_EPD.WHITE) -display.pixel(10, 100, Adafruit_EPD.BLACK) +display.fill(WHITE) +display.pixel(10, 100, BLACK) print("Draw Rectangles") -display.fill_rect(5, 5, 10, 10, Adafruit_EPD.RED) -display.rect(0, 0, 20, 30, Adafruit_EPD.BLACK) +display.fill_rect(5, 5, 10, 10, RED) +display.rect(0, 0, 20, 30, BLACK) print("Draw lines") -display.line(0, 0, display.width - 1, display.height - 1, Adafruit_EPD.BLACK) -display.line(0, display.height - 1, display.width - 1, 0, Adafruit_EPD.RED) +if type(display) == Adafruit_JD79661: + display.line(0, 0, display.width - 1, display.height - 1, YELLOW) + display.line(0, display.height - 1, display.width - 1, 0, YELLOW) +else: + display.line(0, 0, display.width - 1, display.height - 1, BLACK) + display.line(0, display.height - 1, display.width - 1, 0, RED) print("Draw text") -display.text("hello world", 25, 10, Adafruit_EPD.BLACK) +display.text("hello world", 25, 10, BLACK) display.display()