linty!@

Author: ladyada

adafruit_epd/epd.py

@@ -27,23 +27,22 @@
 """
 
 import time
+from micropython import const
 from digitalio import Direction
-import adafruit_framebuf
 from adafruit_epd import mcp_sram
 
-class Adafruit_EPD:
+class Adafruit_EPD: # pylint: disable=too-many-instance-attributes
     """Base class for EPD displays
     """
-    BLACK = 0
-    WHITE = 1
-    INVERSE = 2
-    RED = 3
-    DARK = 4
-    LIGHT = 5
-
-    # pylint: disable=too-many-arguments
-    def __init__(self, width, height, spi, cs_pin, dc_pin, sramcs_pin, rst_pin, busy_pin):
-        # pylint: enable=too-many-arguments
+    BLACK = const(0)
+    WHITE = const(1)
+    INVERSE = const(2)
+    RED = const(3)
+    DARK = const(4)
+    LIGHT = const(5)
+
+
+    def __init__(self, width, height, spi, cs_pin, dc_pin, sramcs_pin, rst_pin, busy_pin): # pylint: disable=too-many-arguments
         self._width = width
         self._height = height
 
@@ -74,8 +73,11 @@ def __init__(self, width, height, spi, cs_pin, dc_pin, sramcs_pin, rst_pin, busy
         if sramcs_pin:
             self.sram = mcp_sram.Adafruit_MCP_SRAM(sramcs_pin, spi)
 
+        self._buf = bytearray(3)
         self._buffer1_size = self._buffer2_size = 0
         self._buffer1 = self._buffer2 = None
+        self._framebuf1 = self._framebuf2 = None
+        self.black_invert = self.red_invert = True
         self.hardware_reset()
 
     def display(self):
@@ -89,9 +91,11 @@ def display(self):
                 pass
             self.sram.cs_pin.value = False
             #send read command
-            self.spi_device.write(bytearray([mcp_sram.Adafruit_MCP_SRAM.SRAM_READ]))
+            self._buf[0] = mcp_sram.Adafruit_MCP_SRAM.SRAM_READ
             #send start address
-            self.spi_device.write(bytearray([0x00, 0x00]))
+            self._buf[1] = 0
+            self._buf[2] = 0
+            self.spi_device.write(self._buf, end=3)
             self.spi_device.unlock()
 
         #first data byte from SRAM will be transfered in at the
@@ -122,9 +126,11 @@ def display(self):
                 pass
             self.sram.cs_pin.value = False
             #send read command
-            self.spi_device.write(bytearray([mcp_sram.Adafruit_MCP_SRAM.SRAM_READ]))
+            self._buf[0] = mcp_sram.Adafruit_MCP_SRAM.SRAM_READ
             #send start address
-            self.spi_device.write(bytearray([(self._buffer1_size >> 8), (self._buffer1_size & 0xFF)]))
+            self._buf[1] = self._buffer1_size >> 8
+            self._buf[2] = self._buffer1_size
+            self.spi_device.write(self._buf, end=3)
             self.spi_device.unlock()
 
         #first data byte from SRAM will be transfered in at the
@@ -151,7 +157,7 @@ def display(self):
 
 
     def hardware_reset(self):
-        # if we have a reset pin, do a hardware reset
+        """If we have a reset pin, do a hardware reset by toggling it"""
         if self._rst:
             self._rst.value = False
             time.sleep(0.1)
@@ -178,6 +184,28 @@ def command(self, cmd, data=None, end=True):
 
         return outbuf[0]
 
+    def power_up(self):
+        """Power up the display in preparation for writing RAM and updating.
+         must be implemented in subclass"""
+        raise NotImplementedError()
+
+    def power_down(self):
+        """Power down the display, must be implemented in subclass"""
+        raise NotImplementedError()
+
+    def update(self):
+        """Update the display from internal memory, must be implemented in subclass"""
+        raise NotImplementedError()
+
+    def write_ram(self, index):
+        """Send the one byte command for starting the RAM write process. Returns
+        the byte read at the same time over SPI. index is the RAM buffer, can be
+        0 or 1 for tri-color displays. must be implemented in subclass"""
+        raise NotImplementedError()
+
+    def set_ram_address(self, x, y):
+        """Set the RAM address location, must be implemented in subclass"""
+        raise NotImplementedError()
 
     def pixel(self, x, y, color):
         """draw a single pixel in the display buffer"""
@@ -200,40 +228,54 @@ def fill(self, color):
             self._framebuf1.fill(black_fill)
             self._framebuf2.fill(red_fill)
 
-    def rect(self, x, y, width, height, color):
+    def rect(self, x, y, width, height, color):     # pylint: disable=too-many-arguments
         """draw a rectangle"""
-        self._framebuf1.rect(x, y, width, height, (color == Adafruit_EPD.BLACK) != self.black_invert)
-        self._framebuf2.rect(x, y, width, height, (color == Adafruit_EPD.RED) != self.red_invert)
+        self._framebuf1.rect(x, y, width, height,
+                             (color == Adafruit_EPD.BLACK) != self.black_invert)
+        self._framebuf2.rect(x, y, width, height,
+                             (color == Adafruit_EPD.RED) != self.red_invert)
 
-    # pylint: disable=too-many-arguments
-    def fill_rect(self, x, y, width, height, color):
+    def fill_rect(self, x, y, width, height, color):     # pylint: disable=too-many-arguments
         """fill a rectangle with the passed color"""
-        self._framebuf1.fill_rect(x, y, width, height, (color == Adafruit_EPD.BLACK) != self.black_invert)
-        self._framebuf2.fill_rect(x, y, width, height, (color == Adafruit_EPD.RED) != self.red_invert)
-
-    def line(self, x_0, y_0, x_1, y_1, color):
-        self._framebuf1.line(x_0, y_0, x_1, y_1, (color == Adafruit_EPD.BLACK) != self.black_invert)
-        self._framebuf2.line(x_0, y_0, x_1, y_1, (color == Adafruit_EPD.RED) != self.red_invert)
+        self._framebuf1.fill_rect(x, y, width, height,
+                                  (color == Adafruit_EPD.BLACK) != self.black_invert)
+        self._framebuf2.fill_rect(x, y, width, height,
+                                  (color == Adafruit_EPD.RED) != self.red_invert)
+
+    def line(self, x_0, y_0, x_1, y_1, color):     # pylint: disable=too-many-arguments
+        """Draw a line from (x_0, y_0) to (x_1, y_1) in passed color"""
+        self._framebuf1.line(x_0, y_0, x_1, y_1,
+                             (color == Adafruit_EPD.BLACK) != self.black_invert)
+        self._framebuf2.line(x_0, y_0, x_1, y_1,
+                             (color == Adafruit_EPD.RED) != self.red_invert)
 
     def text(self, string, x, y, color, *, font_name="font5x8.bin"):
-        self._framebuf1.text(string, x, y, (color == Adafruit_EPD.BLACK) != self.black_invert, font_name=font_name)
-        self._framebuf2.text(string, x, y, (color == Adafruit_EPD.RED) != self.red_invert, font_name=font_name)
+        """Write text string at location (x, y) in given color, using font file"""
+        self._framebuf1.text(string, x, y,
+                             (color == Adafruit_EPD.BLACK) != self.black_invert,
+                             font_name=font_name)
+        self._framebuf2.text(string, x, y,
+                             (color == Adafruit_EPD.RED) != self.red_invert,
+                             font_name=font_name)
 
     @property
     def width(self):
+        """The width of the display, accounting for rotation"""
         if self.rotation in (0, 2):
             return self._width
         return self._height
 
     @property
     def height(self):
+        """The height of the display, accounting for rotation"""
         if self.rotation in (0, 2):
             return self._height
         return self._width
 
     @property
     def rotation(self):
-        return self._framebuf1._rotation
+        """The rotation of the display, can be one of (0, 1, 2, 3)"""
+        return self._framebuf1.rotation
 
     @rotation.setter
     def rotation(self, val):
@@ -271,7 +313,7 @@ def image(self, image):
                 addr = int(((self._width - x) * self._height + y)/8)
 
                 if pixel == (0xFF, 0, 0):
-                    addr = addr + self.bw_bufsize
+                    addr = addr + self._buffer1_size
                 current = self.sram.read8(addr)
 
                 if pixel in ((0xFF, 0, 0), (0, 0, 0)):

adafruit_epd/il0373.py

@@ -30,7 +30,6 @@
 from micropython import const
 import adafruit_framebuf
 from adafruit_epd.epd import Adafruit_EPD
-from adafruit_epd.mcp_sram import Adafruit_MCP_SRAM
 
 _IL0373_POWER_SETTING = const(0x01)
 _IL0373_PANEL_SETTING = const(0x00)
@@ -68,35 +67,38 @@ def __init__(self, width, height, spi, *, cs_pin, dc_pin, sramcs_pin, rst_pin, b
         self._buffer2_size = int(width * height / 8)
 
         if sramcs_pin:
-            self._buffer1_addr = 0
-            self._buffer2_addr = self._buffer1_size
-            self._framebuf1 = adafruit_framebuf.FrameBuffer(self.sram.get_view(0), width, height, buf_format=adafruit_framebuf.MHMSB)
-            self._framebuf2 = adafruit_framebuf.FrameBuffer(self.sram.get_view(self._buffer1_size), width, height, buf_format=adafruit_framebuf.MHMSB)
+            self._buffer1 = self.sram.get_view(0)
+            self._buffer2 = self.sram.get_view(self._buffer1_size)
         else:
             self._buffer1 = bytearray((width * height) // 8)
             self._buffer2 = bytearray((width * height) // 8)
-            # since we have *two* framebuffers - one for red and one for black, we dont subclass but manage manually
-            self._framebuf1 = adafruit_framebuf.FrameBuffer(self._buffer1, width, height, buf_format=adafruit_framebuf.MHMSB)
-            self._framebuf2 = adafruit_framebuf.FrameBuffer(self._buffer2, width, height, buf_format=adafruit_framebuf.MHMSB)
+        # since we have *two* framebuffers - one for red and one for black
+        # we dont subclass but manage manually
+        self._framebuf1 = adafruit_framebuf.FrameBuffer(self._buffer1, width, height,
+                                                        buf_format=adafruit_framebuf.MHMSB)
+        self._framebuf2 = adafruit_framebuf.FrameBuffer(self._buffer2, width, height,
+                                                        buf_format=adafruit_framebuf.MHMSB)
         self.black_invert = True
         self.red_invert = True
         # pylint: enable=too-many-arguments
 
     def begin(self, reset=True):
         """Begin communication with the display and set basic settings"""
-        super(Adafruit_IL0373, self).begin(reset)
+        if reset:
+            self.hardware_reset()
         self.power_down()
 
     def busy_wait(self):
+        """Wait for display to be done with current task, either by polling the
+        busy pin, or pausing"""
         if self._busy:
             while not self._busy.value:
                 pass
         else:
             time.sleep(0.5)
 
     def power_up(self):
-        """power up the display"""
-
+        """Power up the display in preparation for writing RAM and updating"""
         self.hardware_reset()
         self.busy_wait()
 
@@ -117,25 +119,31 @@ def power_up(self):
         self.command(_IL0373_VCM_DC_SETTING, bytearray([0x0A]))
         time.sleep(0.05)
 
-    def power_down():
+    def power_down(self):
+        """Power down the display - required when not actively displaying!"""
         self.command(_IL0373_CDI, bytearray([0x17]))
         self.command(_IL0373_VCM_DC_SETTING, bytearray([0x00]))
         self.command(_IL0373_POWER_OFF)
 
     def update(self):
-        """update the display"""
+        """Update the display from internal memory"""
         self.command(_IL0373_DISPLAY_REFRESH)
         time.sleep(0.1)
         self.busy_wait()
         if not self._busy:
             time.sleep(15)   # wait 15 seconds
 
     def write_ram(self, index):
+        """Send the one byte command for starting the RAM write process. Returns
+        the byte read at the same time over SPI. index is the RAM buffer, can be
+        0 or 1 for tri-color displays."""
         if index == 0:
             return self.command(_IL0373_DTM1, end=False)
         if index == 1:
             return self.command(_IL0373_DTM2, end=False)
         raise RuntimeError("RAM index must be 0 or 1")
 
-    def set_ram_address(self, x, y):
+    def set_ram_address(self, x, y): # pylint: disable=unused-argument, no-self-use
+        """Set the RAM address location, not used on this chipset but required by
+        the superclass"""
         return # on this chip it does nothing

adafruit_epd/mcp_sram.py

@@ -27,12 +27,12 @@
 """
 
 from micropython import const
-import digitalio
-import adafruit_bus_device.spi_device as spi_device
+from adafruit_bus_device import spi_device
 
 SRAM_SEQUENTIAL_MODE = const(1 << 6)
 
 class Adafruit_MCP_SRAM_View:
+    """A interface class that turns an SRAM chip into something like a memoryview"""
     def __init__(self, sram, offset):
         self._sram = sram
         self._offset = offset
@@ -55,16 +55,17 @@ class Adafruit_MCP_SRAM:
 
     def __init__(self, cs_pin, spi):
         # Handle hardware SPI
-        self._spi = spi_device.SPIDevice(spi,cs_pin, baudrate=8000000)
+        self._spi = spi_device.SPIDevice(spi, cs_pin, baudrate=8000000)
         self.spi_device = spi
         self.cs_pin = cs_pin
         self._buf = bytearray(3)
         self._buf[0] = Adafruit_MCP_SRAM.SRAM_WRSR
         self._buf[1] = 0x43
-        with self._spi as spi:
-            spi.write(self._buf, end=2)
+        with self._spi as spidev:
+            spidev.write(self._buf, end=2)
 
     def get_view(self, offset):
+        """Create an object that can be used as a memoryview, with a given offset"""
         return Adafruit_MCP_SRAM_View(self, offset)
 
     def write(self, addr, buf, reg=SRAM_WRITE):